Loads the abbreviated text component from the given code reference table entry using the entry's code as the
visible (abbreviated) text and the entry's description as the abbreviation's expanded text toolTip.

@param entry the CRT entry to use.
359959
public void setTextWithCode(final Object entry) {
		setText(TABLE.getCode(null, entry));
		setToolTip(TABLE.getDescription(null, entry));
	}
84911
public FastReportBuilder addBarcodeColumn(String title, String property,String className, int  barcodeType,boolean showText, int width, boolean fixedWidth,ImageScaleMode imageScaleMode, Style style) throws ColumnBuilderException, ClassNotFoundException {
		AbstractColumn column = ColumnBuilder.getNew()
		.setColumnProperty(property, className)
		.setWidth(width)
		.setTitle(title)
		.setFixedWidth(fixedWidth)
		.setColumnType(ColumnBuilder.COLUMN_TYPE_BARCODE)
		.setStyle(style)
		.setBarcodeType(barcodeType)
		.setShowText(showText)
		.build();

		if (style == null)
			guessStyle(className, column);

		addColumn(column);

		return this;
	}
583471
public void addDeleted(CmsClientSitemapEntry entry) {

        if (!(entry.isNew() && CmsStringUtil.isEmptyOrWhitespaceOnly(entry.getVfsPath()))) {
            removeDeleted(entry.getId().toString());
            getDeleted().insertItem(createDeletedItem(entry), 0);
        }
        removeModified(entry.getId().toString());
        m_clipboardButton.enableClearDeleted(true);
    }
1342271
public void add(FutureReadResultEntry entry) {
        synchronized (this.reads) {
            Exceptions.checkNotClosed(this.closed, this);
            this.reads.add(entry);
        }
    }
1243091
public void updateSet (String setName, DSet.Entry entry)
    {
        requestEntryUpdate(setName, getSet(setName), entry);
    }
157719
function (charCode, keyCode) {
                var dataModel = this._dataModel;
                var report;
                if (domEvent.isNavigationKey(keyCode)) {
                    var newIdx;
                    var validationKey = false;
                    if (keyCode == domEvent.KC_LEFT || keyCode == domEvent.KC_UP) {
                        newIdx = dataModel.selectedIdx - 1;
                    } else if (keyCode == domEvent.KC_RIGHT || keyCode == domEvent.KC_DOWN) {
                        newIdx = dataModel.selectedIdx + 1;
                    } else if (keyCode == domEvent.KC_PAGE_UP) {
                        newIdx = dataModel.selectedIdx - (dataModel.pageSize - 1);
                    } else if (keyCode == domEvent.KC_PAGE_DOWN) {
                        newIdx = dataModel.selectedIdx + (dataModel.pageSize - 1);
                    } else if (keyCode == domEvent.KC_HOME) {
                        newIdx = 0;
                    } else if (keyCode == domEvent.KC_END) {
                        newIdx = dataModel.listContent.length - 1;
                    } else if (keyCode == domEvent.KC_ENTER) {
                        // when pressing enter, the currently highlighted item in the dropdown becomes the current
                        // value:
                        newIdx = dataModel.selectedIdx;
                        validationKey = true;
                    } else if (keyCode == domEvent.KC_ESCAPE) {
                        // pressing escape has no effect if the popup is not open
                        // it only closes the popup when it is open (does not update the data model)
                        if (this._listWidget) {
                            report = this._createReport(false);
                            report.displayDropDown = false;
                            report.cancelKeyStroke = true;
                            jsonUtils.setValue(dataModel, 'selectedIdx', dataModel.displayIdx);
                        }
                    } else if (keyCode == domEvent.KC_TAB) {
                        // when pressing tab, the currently selected item stays the current value:
                        newIdx = dataModel.displayIdx;
                        validationKey = true;
                    }
                    if (newIdx != null) {
                        this._setLastTypedKeys(null);
                        this._setDisplayIdx(newIdx);
                        report = this._createReport(validationKey);
                        // never cancel TAB keystroke, and ENTER should not be canceled when the list widget is no
                        // longer displayed
                        report.cancelKeyStroke = (keyCode != domEvent.KC_TAB && (keyCode != domEvent.KC_ENTER || this._listWidget != null));
                        if (this._listWidget && validationKey) {
                            report.displayDropDown = false;
                        }
                    }
                } else {
                    var lastTypedKeys = dataModel.lastTypedKeys;
                    var newMatch = (lastTypedKeys == null);
                    if (newMatch) {
                        lastTypedKeys = "";
                    }
                    var newLastTypedKeys;
                    if (keyCode == domEvent.KC_BACKSPACE) {
                        newLastTypedKeys = this._getTypedValueOnDelete(keyCode, lastTypedKeys, lastTypedKeys.length, lastTypedKeys.length).nextValue;
                        // we do not look for a new match when pressing backspace, only save the resulting lastTypedKeys
                    } else {
                        newLastTypedKeys = this._getTypedValue(charCode, lastTypedKeys, lastTypedKeys.length, lastTypedKeys.length).nextValue;
                        newLastTypedKeys = newLastTypedKeys.toLowerCase();
                        var matchingIndex = this._findMatch(newLastTypedKeys, newMatch);
                        if (matchingIndex == -1) {
                            matchingIndex = this._findLetterMatch(newLastTypedKeys);
                        }
                        if (matchingIndex > -1) {
                            this._setDisplayIdx(matchingIndex);
                        }
                    }
                    report = this._createReport(false);
                    report.cancelKeyStroke = true;
                    this._setLastTypedKeys(newLastTypedKeys);
                }
                return report;
            }
640057
public void viewDocument(DocumentEntry entry)
   {
      InputStream is = null;

      try
      {
         is = new DocumentInputStream(entry);
         byte[] data = new byte[is.available()];
         is.read(data);
         m_model.setData(data);
         updateTables();
      }

      catch (IOException ex)
      {
         throw new RuntimeException(ex);
      }

      finally
      {
         StreamHelper.closeQuietly(is);
      }

   }
138431
protected void loadBasicStyle()
    {
        ctx.updateForGraphics(style, g);
        
        display = style.getProperty("display");
        if (display == null) display = CSSProperty.Display.INLINE;
        
        CSSProperty.Float floating = style.getProperty("float");
        if (floating == null) floating = BlockBox.FLOAT_NONE;
        
        position = style.getProperty("position");
        if (position == null) position = BlockBox.POS_STATIC;
        
        //apply combination rules
        //http://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo
        if (display == ElementBox.DISPLAY_NONE)
        {
            position = BlockBox.POS_STATIC;
            floating = BlockBox.FLOAT_NONE;
        }
        else if (position == BlockBox.POS_ABSOLUTE || position == BlockBox.POS_FIXED)
        {
            floating = BlockBox.FLOAT_NONE;
        }
        //compute the display computed value
        if (floating != BlockBox.FLOAT_NONE || position == BlockBox.POS_ABSOLUTE || position == BlockBox.POS_FIXED || isRootElement())
        {
            if (display == DISPLAY_INLINE_TABLE)
                display = DISPLAY_TABLE;
            else if (display == DISPLAY_INLINE ||
                     display == DISPLAY_RUN_IN ||
                     display == DISPLAY_TABLE_ROW_GROUP ||
                     display == DISPLAY_TABLE_COLUMN ||
                     display == DISPLAY_TABLE_COLUMN_GROUP ||
                     display == DISPLAY_TABLE_HEADER_GROUP ||
                     display == DISPLAY_TABLE_FOOTER_GROUP ||
                     display == DISPLAY_TABLE_ROW ||
                     display == DISPLAY_TABLE_CELL ||
                     display == DISPLAY_TABLE_CAPTION ||
                     display == DISPLAY_INLINE_BLOCK)
                display = DISPLAY_BLOCK;
        }

        isblock = (display == DISPLAY_BLOCK);
        displayed = (display != DISPLAY_NONE && display != DISPLAY_TABLE_COLUMN);
        visible = (style.getProperty("visibility") != CSSProperty.Visibility.HIDDEN); 
        
        //line height
        CSSProperty.LineHeight lh = style.getProperty("line-height");
        if (lh == null || lh == CSSProperty.LineHeight.NORMAL)
            lineHeight = Math.round(DEFAULT_LINE_HEIGHT * ctx.getFontHeight());
        else if (lh == CSSProperty.LineHeight.length)
        {
            TermLength len = style.getValue(TermLength.class, "line-height");
            lineHeight = (int) ctx.pxLength(len);
        }
        else if (lh == CSSProperty.LineHeight.percentage)
        {
            TermPercent len = style.getValue(TermPercent.class, "line-height");
            lineHeight = (int) ctx.pxLength(len, ctx.getFontHeight()); 
        }
        else //must be INTEGER or NUMBER
        {
            Term<?> len = style.getValue("line-height", true);
            float r;
            if (len instanceof TermInteger)
                r = ((TermInteger) len).getValue();
            else
                r = ((TermNumber) len).getValue();
            lineHeight = Math.round(r * ctx.getFontHeight());
        }

        //whitespace
        whitespace = style.getProperty("white-space");
        if (whitespace == null) whitespace = WHITESPACE_NORMAL;
        
        //background
        loadBackground();
        
        //z-index
        CSSProperty.ZIndex z = style.getProperty("z-index");
        if (z != null && z != ZIndex.AUTO)
        {
            zset = true;
            Term<?> zterm = style.getValue("z-index", true);
            if (zterm instanceof TermInteger)
                zIndex = ((TermInteger) zterm).getValue().intValue();
            else
                zset = false;
        }
        else
            zset = false;
        
        //transformations -- applied on block-level or atomic inline-level elements only
        if (isBlock() || isReplaced())
            transform = style.getProperty("transform");
        if (transform == null) transform = CSSProperty.Transform.NONE;
    }
144675
protected String getInnerXmlForEntry(CmsXmlSitemapUrlBean entry) {

        StringBuffer buffer = new StringBuffer();
        entry.writeElement(buffer, "loc", entry.getUrl());
        entry.writeLastmod(buffer);
        entry.writeChangefreq(buffer);
        entry.writePriority(buffer);
        return buffer.toString();
    }
539282
public static void ensureContentType(CDAEntry entry, CDAClient client) {
    CDAContentType contentType = entry.contentType();
    if (contentType != null) {
      return;
    }

    String contentTypeId = extractNested(entry.attrs(), "contentType", "sys", "id");
    try {
      contentType = client.cacheTypeWithId(contentTypeId).blockingFirst();
    } catch (CDAResourceNotFoundException e) {
      throw new CDAContentTypeNotFoundException(entry.id(), CDAEntry.class, contentTypeId, e);
    }

    entry.setContentType(contentType);
  }
65303
public final void setFormat(String value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setFormat", value);
        jmo.getPayloadPart().setField(JsPayloadAccess.FORMAT, value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setFormat");
    }
1174580
public void addFormEntry(final JLabel mainLabel, final JLabel minorLabel, final JComponent component) {
        add(mainLabel, new GridBagConstraints(0, _rowCounter, 1, 1, 0d, 0d, GridBagConstraints.NORTHWEST,
                GridBagConstraints.BOTH, INSETS, 0, 0));

        if (minorLabel != null) {
            add(minorLabel, new GridBagConstraints(0, _rowCounter + 1, 1, 1, 0d, 1d, GridBagConstraints.NORTHWEST,
                    GridBagConstraints.BOTH, INSETS, 0, 0));
        }

        add(component, new GridBagConstraints(1, _rowCounter, 1, 2, 1d, 1d, GridBagConstraints.NORTHEAST,
                GridBagConstraints.BOTH, INSETS, 0, 0));

        // each property spans two "rows"
        _rowCounter = _rowCounter + 2;
    }
199628
@Override
    public void add(QueryableEntry entry) {
        if (++resultSize > resultLimit) {
            throw new QueryResultSizeExceededException();
        }

        rows.add(orderAndLimitExpected ? entry : convertEntryToRow(entry));
    }
801587
public void updateInNavigation(CmsClientSitemapEntry entry) {

        if (entry.isInNavigation()) {
            m_inNavigationStyle.setValue(null);
            getListItemWidget().setTitleEditable(true);
        } else {
            m_inNavigationStyle.setValue(CSS.notInNavigationEntry());
            getListItemWidget().setTitleEditable(false);
        }
    }
209595
public void addFormEntry(String mainLabelText, final String minorLabelText, final JComponent component) {
        if (!mainLabelText.endsWith(":")) {
            mainLabelText += ":";
        }

        final DCLabel mainLabel = DCLabel.dark(mainLabelText);
        mainLabel.setFont(WidgetUtils.FONT_NORMAL);
        mainLabel.setBorder(new EmptyBorder(6, 0, 0, 0));

        final JXLabel minorLabel;
        if (StringUtils.isNullOrEmpty(minorLabelText)) {
            minorLabel = null;
        } else {
            mainLabel.setToolTipText(minorLabelText);

            minorLabel = new JXLabel(minorLabelText);
            minorLabel.setLineWrap(true);
            minorLabel.setFont(WidgetUtils.FONT_SMALL);
            minorLabel.setBorder(new EmptyBorder(0, 4, 0, 0));
            minorLabel.setVerticalAlignment(JXLabel.TOP);
            minorLabel.setPreferredSize(new Dimension(FIELD_LABEL_WIDTH - 4, 0));
        }

        addFormEntry(mainLabel, minorLabel, component);
    }
395846
static <K, V> Map.Entry<K, V> parseEntry(CodedInputStream input, Metadata<K, V> metadata,
            ExtensionRegistryLite extensionRegistry) throws IOException {
        K key = metadata.defaultKey;
        V value = metadata.defaultValue;
        while (true) {
            int tag = input.readTag();
            if (tag == 0) {
                break;
            }
            if (tag == CodedConstant.makeTag(KEY_FIELD_NUMBER, metadata.keyType.getWireType())) {
                key = parseField(input, extensionRegistry, metadata.keyType, key);
            } else if (tag == CodedConstant.makeTag(VALUE_FIELD_NUMBER, metadata.valueType.getWireType())) {
                value = parseField(input, extensionRegistry, metadata.valueType, value);
            } else {
                if (!input.skipField(tag)) {
                    break;
                }
            }
        }
        return new AbstractMap.SimpleImmutableEntry<K, V>(key, value);
    }
1324472
private static void addDescription(Entry entry, String description) {
        try {
            entry.add(SchemaConstants.OBJECT_CLASS_ATTRIBUTE, SchemaConstants.DESCRIPTIVE_OBJECT_OC);
            if (description == null) {
                entry.add(SchemaConstants.EMPTY_FLAG_ATTRIBUTE, String.valueOf(false)); // case 1
            } else if (description.isEmpty()) {
                entry.add(SchemaConstants.EMPTY_FLAG_ATTRIBUTE, String.valueOf(true)); // case 2
            } else {
                entry.add(SchemaConstants.STRING_ATTRIBUTE, description); // case 3
            }
        } catch (LdapException e) {
            throw new LdapRuntimeException(e);
        }
    }