Adds the label field
183149
private function AddLabelField()
    {
        $name = 'Label';
        $field = Input::Text($name, $this->select->GetLabel());
        $this->AddField($field);
    }
1289828
private function AddTitleField()
    {
        $name = 'Title';
        $this->AddField(Input::Text($name, $this->page->GetTitle()));
    }
801115
def add_label(self, doc, label, update_index=True):
        
        label = copy.copy(label)
        assert(label in self.labels.values())
        doc.add_label(label)
        if update_index:
            self.upd_doc(doc)
            self.commit()
810780
def add_label_cycle(self, label, cycle):
        """"""
        self.labels.append(label)
        self.cycles.append(cycle)
811447
def get_model_field_label_and_value(instance, field_name) -> (str, str):
    
    label = field_name
    value = str(getattr(instance, field_name))
    for f in instance._meta.fields:
        if f.attname == field_name:
            label = f.verbose_name
            if hasattr(f, 'choices') and len(f.choices) > 0:
                value = choices_label(f.choices, value)
            break
    return label, force_text(value)
347323
function addlabel(name, opts) {
    opts = opts || {};

    var type  = opts.type;
    var token = opts.token;
    var islet = opts.islet;

    // Define label in the current function in the current scope.
    if (type === "exception") {
      if (_.has(funct["(context)"], name)) {
        if (funct[name] !== true && !state.option.node) {
          warning("W002", state.tokens.next, name);
        }
      }
    }

    if (_.has(funct, name) && !funct["(global)"]) {
      if (funct[name] === true) {
        if (state.option.latedef) {
          if ((state.option.latedef === true && _.contains([funct[name], type], "unction")) ||
              !_.contains([funct[name], type], "unction")) {
            warning("W003", state.tokens.next, name);
          }
        }
      } else {
        if ((!state.option.shadow || _.contains([ "inner", "outer" ], state.option.shadow)) &&
            type !== "exception" || funct["(blockscope)"].getlabel(name)) {
          warning("W004", state.tokens.next, name);
        }
      }
    }

    if (funct["(context)"] && _.has(funct["(context)"], name) && type !== "function") {
      if (state.option.shadow === "outer") {
        warning("W123", state.tokens.next, name);
      }
    }

    // if the identifier is from a let, adds it only to the current blockscope
    if (islet) {
      funct["(blockscope)"].current.add(name, type, state.tokens.curr);
    } else {
      funct["(blockscope)"].shadow(name);
      funct[name] = type;

      if (token) {
        funct["(tokens)"][name] = token;
      }

      setprop(funct, name, { unused: opts.unused || false });

      if (funct["(global)"]) {
        global[name] = funct;
        if (_.has(implied, name)) {
          if (state.option.latedef) {
            if ((state.option.latedef === true && _.contains([funct[name], type], "unction")) ||
                !_.contains([funct[name], type], "unction")) {
              warning("W003", state.tokens.next, name);
            }
          }

          delete implied[name];
        }
      } else {
        scope[name] = funct;
      }
    }
  }
438918
void bindField(AbstractField<?> field, String property) {

        m_group.bind(field, property);

        field.setCaption(CmsVaadinUtils.getMessageText("label." + property));
        field.setDescription(CmsVaadinUtils.getMessageText("label." + property + ".help"));
    }
39938
protected void addInputField(String label, Widget inputWidget) {

        FlowPanel row = new FlowPanel();
        row.setStyleName(I_CmsLayoutBundle.INSTANCE.groupcontainerCss().inputRow());
        CmsLabel labelWidget = new CmsLabel(label);
        labelWidget.setStyleName(I_CmsLayoutBundle.INSTANCE.groupcontainerCss().inputLabel());
        row.add(labelWidget);
        inputWidget.addStyleName(I_CmsLayoutBundle.INSTANCE.groupcontainerCss().inputBox());
        row.add(inputWidget);
        m_dialogContent.add(row);
    }
1090031
private void addFieldToLayout(final WComponent input, final String labelText,
			final String labelHint) {
		WField field = layout.addField(labelText, input);

		if (labelHint != null) {
			field.getLabel().setHint(labelHint);
		}
	}
1058650
public function addFields($fields=NULL, $label=NULL) {
		if (isset($fields)) {
			if (!$fields instanceof HtmlFormFields) {
				if (!\is_array($fields)) {
					$fields=\func_get_args();
					$end=\end($fields);
					if (\is_string($end)) {
						$label=$end;
						\array_pop($fields);
					} else
						$label=NULL;
				}
				$this->_fields=\array_merge($this->_fields, $fields);
				$fields=new HtmlFormFields("fields-" . $this->identifier . "-" . $this->count(), $fields);
			}
			if (isset($label)){
				$fields->wrap("<div class='field'><label>{$label}</label>","</div>");
			}
		} else {
			$fields=new HtmlFormFields("fields-" . $this->identifier . "-" . $this->count());
		}
		$this->addItem($fields);
		return $fields;
	}
404862
function addSubsectionFieldsFromTable($, fields, $table) {
    // Iterate through each input inside the table.
    $table.find(':input').each(function(i) {
      var $input      = $(this),
          fieldLabel  = getFieldLabelFromInput($, $input);

      // If we couldn't extract a label from the field, generate one.
      if(!fieldLabel) {
        fieldLabel = 'Untitled Field #' + (i + 1);
      }

      fields[fieldLabel] = getFieldData($, $input);
    });

    return fields;
  }
1094521
public void addText(String label,
                        String value)
    {
        Composite c = new Composite();
        c.add(value);
        addField(label,c);
    }
1369001
def _label(self, line):
        '''

        '''
        label = self._setup('LABEL', line)
        self.labels += [ label ]
690103
def get_label(self):
        
        if self.label is None:
            self.label = self.get_field('label')
        return self.label
601
def get_field_label(self, field_name, field=None):
        
        label = None
        if field is not None:
            label = getattr(field, 'verbose_name', None)
            if label is None:
                label = getattr(field, 'name', None)
        if label is None:
            label = field_name
        return label.capitalize()
607545
def _add_form_fields(obj, lines):
    
    lines.append("**Form fields:**")
    lines.append("")
    for name, field in obj.base_fields.items():
        field_type = "{}.{}".format(field.__class__.__module__, field.__class__.__name__)
        tpl = "* ``{name}``: {label} (:class:`~{field_type}`)"
        lines.append(tpl.format(
            name=name,
            field=field,
            label=field.label or name.replace('_', ' ').title(),
            field_type=field_type
        ))
459107
function _render_label(){
	
	var buf = new Array();

	// Add the label.
	buf.push('<label for="');
	buf.push(anchor.mid);
	buf.push('" class="select">');
	buf.push(anchor.mlabel);
	buf.push('</label>');

	return buf.join('');	
    }