Generate a text event.

@param mRtx
Read Transaction.
487610
private void generateText(final INodeReadTrx paramRtx) {
        try {
            mContHandler.characters(paramRtx.getValueOfCurrentNode().toCharArray(), 0, paramRtx
                .getValueOfCurrentNode().length());
        } catch (final SAXException exc) {
            exc.printStackTrace();
        }
    }
1254640
function text(index, value) {
    ngDevMode &&
        assertEqual(viewData[BINDING_INDEX], -1, 'text nodes should be created before bindings');
    ngDevMode && ngDevMode.rendererCreateTextNode++;
    var textNode = createTextNode(value, renderer);
    var node = createLNode(index, 3 /* Element */, textNode, null, null);
    // Text nodes are self closing.
    isParent = false;
    appendChild(getParentLNode(node), textNode, viewData);
}
687146
private void _updateActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__updateActionPerformed
        jTextPane1.setText("");
        String text = new String(buffer, 0, pos);
        String[] lines = text.split("\n");

        Style style = jTextPane1.getStyle("INFO");
        for (String line : lines) {
            if (line.startsWith("o ")) {
                line = line.substring(2);
                style = jTextPane1.getStyle("OUTPUT");
            } else if (line.startsWith("i ")) {
                line = line.substring(2);
                style = jTextPane1.getStyle("INFO");
            } else if (line.startsWith("w ")) {
                line = line.substring(2);
                style = jTextPane1.getStyle("WARN");
            } else if (line.startsWith("e ")) {
                line = line.substring(2);
                style = jTextPane1.getStyle("ERROR");
            }

            try {
                jTextPane1.getDocument().insertString(jTextPane1.getDocument().getLength(), line + "\n", style);
                jTextPane1.setCaretPosition(jTextPane1.getDocument().getLength());
            } catch (Exception e) {
                 Log.Err.println(e.getMessage());
            }
        }
    }
1214705
protected XMLEvent createNextEvent(boolean checkEOD, int type)
        throws XMLStreamException
    {
        try {
            XMLEvent evt = mAllocator.allocate(mReader);
            if (checkEOD && type == END_DOCUMENT) {
                updateStateEndDocument();
            }
            return evt;
        } catch (RuntimeException rex) {
            throw _checkUnwrap(rex);
        }
    }
1370695
def OnCellText(self, event):
        """"""

        row, col, _ = self.grid.actions.cursor
        self.grid.GetTable().SetValue(row, col, event.code)

        event.Skip()
151030
private void onMessageRead(MessageReadEvent event) {
        handler.post(() -> listener.onMessageRead(event));
        log("Event published " + event.toString());
    }
274334
@Override
    public void updateFieldContent(String text) {

        if (!m_initialUpdateCalled) {
            m_initialUpdateCalled = true;
            if ("".equals(text)) {
                valueChange(false);
                Scheduler.get().scheduleFixedDelay(new RepeatingCommand() {

                    public boolean execute() {

                        if (isAttached()) {
                            valueChange(false);
                            return true;
                        } else {
                            return false;
                        }
                    }
                }, 100);
                return;
            }

        }
        super.updateFieldContent(text);
    }
317192
def text(self):
        
        if self.m_name == -1 or self.m_event != TEXT:
            return ''

        return self.sb[self.m_name]
1290120
public function event($title, $text, $type = Event::INFO, array $tags = array(), $timestamp = null)
    {
        try {
            $this->sendEvent($this->eventFactory->event($title, $text, $type, $tags, $timestamp));
        } catch (\Exception $exception) {
            $this->logException($exception);
        }

        return $this;
    }
511620
public void processMessageTimeout(String strTrxID)
    {
        MessageLog recMessageLog = (MessageLog)this.getMainRecord();
        BaseMessage message = (BaseMessage)recMessageLog.createMessage(strTrxID);
        String strMessageError = "Message timeout";
        BaseMessage messageReply = (BaseMessage)BaseMessageProcessor.processErrorMessage(this, message, strMessageError);
        if (messageReply != null)    // No reply if null.
        {
            BaseMessageTransport transport = this.getMessageTransport(message);
            transport.setupReplyMessage(messageReply, message, MessageInfoType.REPLY, MessageType.MESSAGE_IN);
            transport.processIncomingMessage(messageReply, message);
        }
    }
1214485
public void textChanged(TextEvent textEvent) {
        try {
            // get the control that has fired the event,
            XControl xControl = (XControl) UnoRuntime.queryInterface(XControl.class, textEvent.Source);
            XControlModel xControlModel = xControl.getModel();
            XPropertySet xPSet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, xControlModel);
            String sName = (String) xPSet.getPropertyValue("Name");
            // just in case the listener has been added to several controls,
            // we make sure we refer to the right one
            if (sName.equals("TextField1")){
                String sText = (String) xPSet.getPropertyValue("Text");
                System.out.println(sText);
                // insert your code here to validate the text of the control...
            }
        }catch (com.sun.star.uno.Exception ex){
            /* perform individual exception handling here.
             * Possible exception types are:
             * com.sun.star.lang.WrappedTargetException,
             * com.sun.star.beans.UnknownPropertyException,
             * com.sun.star.uno.Exception
             */
            ex.printStackTrace(System.out);
        }
    }
196423
public void setTabText(int index, String text) {
        TextView tv = (TextView) mTabTitleViews.get(index);

        if (tv != null) {
            tv.setText(text);
        }
    }
680850
@Override
    public void setText(final String text, final String charset, final String subtype) throws MessagingException {
        throw new IllegalWriteException("Mock messages are read-only");
    }
1281494
public void onMessage(Mtp2Buffer rxFrame, Mtp2 mtp2) {
        // | ----------------------- TO L4 --------------------------- |
        // | --------------------- SIF ------------------------ |
        // FSN BSN LEN SIO DPC/OPC,SLS HEADING LEN
        // b1 b0 0e 01 01 80 00 00 21 70 01 02 03 04 05 06 0f CRC CRC
        int sio = rxFrame.frame[3] & 0xFF;
        int subserviceIndicator = (sio >> 4) & 0x0F;
        int serviceIndicator = sio & 0x0F;
        int ni = (subserviceIndicator & 0x0C); // local NI(network Indicator) form msg., 0x0C, since we store it as shifted
                                               // value.
        // int dpc = (sif[0] & 0xff | ((sif[1] & 0x3f) << 8));
        // int opc = ((sif[1] & 0xC0) >> 6) | ((sif[2] & 0xff) << 2) | ((sif[3]
        // & 0x0f) << 10);
        // int sls = (sif[3] & 0xf0) >>> 4;
        int dpc = dpc(rxFrame.frame, 4); // 1 - cause sif contains sio, even though its also passed as arg.
        int opc = opc(rxFrame.frame, 4);
        int sls = sls(rxFrame.frame, 4);

        // check SSI, Q.704 Figure 25, seems like if its bad, we discard.
        if (this.ni != ni) {
            if (logger.isEnabledFor(Level.ERROR)) {
                logger.error(String.format("(%s) Received MSSU with bad SSI, discarding! ni:" + ni + " thisni:" + this.ni
                        + " [si=" + serviceIndicator + ",ssi=" + subserviceIndicator + ", dpc=" + dpc + ", opc=" + opc
                        + ", sls=" + sls + "] data: ", mtp2.getName())
                        + Arrays.toString(rxFrame.frame));
            }
            return;
        }

        switch (serviceIndicator) {
            case LINK_MANAGEMENT:
                int h0 = rxFrame.frame[8] & 0x0f;
                int h1 = (rxFrame.frame[8] & 0xf0) >>> 4;

                if (logger.isDebugEnabled()) {
                    logger.debug(String.format("(%s) Signalling network management", mtp2.getName()));
                }

                if (h0 == 0) {
                    if (logger.isDebugEnabled()) {
                        logger.debug(String.format("(%s) Changeover management", mtp2.getName()));
                    }
                } else if (h0 == 7 && h1 == 1) {
                    if (logger.isDebugEnabled()) {
                        logger.debug(String.format("(%s) TRA received", mtp2.getName()));
                    }
                }
                // FIX ME
                break;
            case LINK_TESTING:
                h0 = rxFrame.frame[8] & 0x0f;
                h1 = (rxFrame.frame[8] & 0xf0) >>> 4;

                int len = (rxFrame.frame[9] & 0xf0) >>> 4;
                if (h0 == 1 && h1 == 1) {
                    if (logger.isDebugEnabled()) {
                        logger.debug(String.format("(%s) Received SLTM", mtp2.getName()));
                    }
                    // receive SLTM from remote end
                    // create response

                    // change order of opc/dpc in SLTA !
                    writeRoutingLabel(this.localFrame, sio, this.ni, sls, opc, dpc);
                    // slta[0] = (byte) sio;
                    this.localFrame[5] = 0x021;
                    // +1 cause we copy LEN byte also.
                    System.arraycopy(rxFrame.frame, 9, this.localFrame, 6, len + 1);

                    if (logger.isDebugEnabled()) {
                        logger.debug(String.format("(%s) Responding with SLTA", mtp2.getName()));
                    }
                    mtp2.send(this.localFrame, len + 9);
                } else if (h0 == 1 && h1 == 2) {
                    // receive SLTA from remote end
                    if (logger.isDebugEnabled()) {
                        logger.debug(String.format("(%s) Received SLTA", mtp2.getName()));
                    }

                    // checking pattern
                    if (checkPattern(rxFrame, len, SLTM_PATTERN)) {
                        // test message is acknowledged
                        mtp2.sltmTest.ack();

                        // notify top layer that link is up
                        if (!l4IsUp) {
                            l4IsUp = true;
                            linkUp(mtp2);
                        }
                    } else {
                        if (logger.isEnabledFor(Level.WARN)) {
                            logger.warn("SLTA pattern does not match: \n" + Arrays.toString(rxFrame.frame) + "\n"
                                    + Arrays.toString(SLTM_PATTERN));
                        }
                    }
                } else {
                    if (logger.isEnabledFor(Level.WARN)) {
                        logger.warn(String.format("(%s) Unexpected message type", mtp2.getName()));
                    }
                }
                break;
            case _SI_SERVICE_SCCP:
                if (logger.isDebugEnabled()) {
                    logger.debug("Received SCCP MSU");
                }

                if (mtp3Listener != null) {

                    // | ----------------------- TO L4 --------------------------- |
                    // | --------------------- SIF ------------------------ |
                    // FSN BSN LEN SIO DPC/OPC,SLS HEADING LEN
                    // b1 b0 0e 01 01 80 00 00 21 70 01 02 03 04 05 06 0f CRC CRC
                    byte[] messageBuffer = new byte[rxFrame.len - 5]; // -5 = FSN(1) + BSN(1) + LEN(1) +2xCRC(1)
                    System.arraycopy(rxFrame.frame, 3, messageBuffer, 0, rxFrame.len - 5);
                    // messageBuffer[0] = (byte) sio;
                    try {
                        mtp3Listener.receive(messageBuffer);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                break;
            case _SI_SERVICE_ISUP:
                if (logger.isDebugEnabled()) {
                    logger.debug("Received ISUP MSU");

                }
                if (mtp3Listener != null) {
                    byte[] messageBuffer = new byte[rxFrame.len - 5];
                    System.arraycopy(rxFrame.frame, 3, messageBuffer, 0, rxFrame.len - 5);
                    // messageBuffer[0] = (byte) sio;
                    try {
                        mtp3Listener.receive(messageBuffer);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                break;
            default:
                if (logger.isEnabledFor(Level.WARN)) {
                    logger.warn("Received MSU for UNKNOWN SERVICE!!!!!!!!!!!: " + Utils.dump(rxFrame.frame, rxFrame.len, false));
                }
                break;
        }
    }
756710
protected void executeTx(final TxRunnable r, final TxRunnable errorHandler) throws Exception {
        Transaction transaction = beginTransaction();
        configureTransDefault(transaction);
        processTransactionError(transaction, t -> {
            try {
                r.run(t);
                t.commit();
            } catch (Throwable e) {
                t.rollback(e);
                throw e;
            } finally {
                t.end();
            }
            return null;
        }, errorHandler != null ? (TxCallable) t -> {
            errorHandler.run(t);
            return null;
        } : null);
    }
20031
@Override
	public void onTxRollback(Transaction tx) {
		if (!tx.isReadOnly() && enableLogging) {
			rollback(tx);
			LogSeqNum lsn = new RollbackRecord(txNum).writeToLog();
			VanillaDb.logMgr().flush(lsn);
		}
	}
1114695
private XMLEvent nextEvent(String location) throws Exception {
        XMLEvent event = reader.nextEvent();
//        System.out.println(location + event.toString().replace('\n', ' ') + " " + event.getClass().getSimpleName());
        return event;
    }