JSC::JSValue JSMessageEvent::initMessageEvent(JSC::ExecState* exec)
{
const UString& typeArg = exec->argument(0).toString(exec);
bool canBubbleArg = exec->argument(1).toBoolean(exec);
bool cancelableArg = exec->argument(2).toBoolean(exec);
RefPtr<SerializedScriptValue> dataArg = SerializedScriptValue::create(exec, exec->argument(3));
if (exec->hadException())
return jsUndefined();
const UString& originArg = exec->argument(4).toString(exec);
const UString& lastEventIdArg = exec->argument(5).toString(exec);
DOMWindow* sourceArg = toDOMWindow(exec->argument(6));
OwnPtr<MessagePortArray> messagePorts;
if (!exec->argument(7).isUndefinedOrNull()) {
messagePorts = adoptPtr(new MessagePortArray);
fillMessagePortArray(exec, exec->argument(7), *messagePorts);
if (exec->hadException())
return jsUndefined();
}
MessageEvent* event = static_cast<MessageEvent*>(this->impl());
event->initMessageEvent(ustringToAtomicString(typeArg), canBubbleArg, cancelableArg, dataArg.release(), ustringToString(originArg), ustringToString(lastEventIdArg), sourceArg, messagePorts.release());
JSValue result;
if (SerializedScriptValue* serializedValue = event->dataAsSerializedScriptValue())
result = serializedValue->deserialize(exec, globalObject(), NonThrowing);
else
result = jsNull();
m_data.set(exec->globalData(), this, result);
return jsUndefined();
}
bool ChannelService::EventSunk(ChannelPipeline* pipeline, MessageEvent<DatagramPacket>& e)
{
DatagramPacket* packet = e.GetMessage();
Channel* ch = e.GetChannel();
DatagramChannel* sc = (DatagramChannel*) ch;
return sc->Send(packet->GetInetAddress(), &(packet->GetBuffer())) > 0;
}
void TcpAcceptor :: CreateEvent()
{
if (m_oFDQueue.empty())
{
return;
}
m_oMutex.lock();
int iCreatePerTime = 200;
while ((!m_oFDQueue.empty()) && iCreatePerTime--)
{
AcceptData * poData = m_oFDQueue.front();
m_oFDQueue.pop();
//create event for this fd
MessageEvent * poMessageEvent = new MessageEvent(MessageEventType_RECV, poData->fd,
poData->oAddr, m_poEventLoop, m_poNetWork);
poMessageEvent->AddEvent(EPOLLIN);
m_vecCreatedEvent.push_back(poMessageEvent);
delete poData;
}
m_oMutex.unlock();
}
v8::Handle<v8::Value> V8MessageEvent::initMessageEventCallback(const v8::Arguments& args)
{
MessageEvent* event = V8MessageEvent::toNative(args.Holder());
String typeArg = toWebCoreString(args[0]);
bool canBubbleArg = args[1]->BooleanValue();
bool cancelableArg = args[2]->BooleanValue();
ScriptValue dataArg = ScriptValue(args[3]);
String originArg = toWebCoreString(args[4]);
String lastEventIdArg = toWebCoreString(args[5]);
DOMWindow* sourceArg = 0;
if (args[6]->IsObject()) {
v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(args[6]);
v8::Handle<v8::Object> window = wrapper->FindInstanceInPrototypeChain(V8DOMWindow::GetTemplate(args.GetIsolate()));
if (!window.IsEmpty())
sourceArg = V8DOMWindow::toNative(window);
}
OwnPtr<MessagePortArray> portArray;
if (!isUndefinedOrNull(args[7])) {
portArray = adoptPtr(new MessagePortArray);
if (!getMessagePortArray(args[7], *portArray, args.GetIsolate()))
return v8::Undefined();
}
event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, portArray.release());
return v8::Undefined();
}
v8::Handle<v8::Value> V8MessageEvent::initMessageEventCallback(const v8::Arguments& args)
{
INC_STATS("DOM.MessageEvent.initMessageEvent");
MessageEvent* event = V8MessageEvent::toNative(args.Holder());
String typeArg = v8ValueToWebCoreString(args[0]);
bool canBubbleArg = args[1]->BooleanValue();
bool cancelableArg = args[2]->BooleanValue();
RefPtr<SerializedScriptValue> dataArg = SerializedScriptValue::create(args[3]);
String originArg = v8ValueToWebCoreString(args[4]);
String lastEventIdArg = v8ValueToWebCoreString(args[5]);
DOMWindow* sourceArg = 0;
if (args[6]->IsObject()) {
v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(args[6]);
v8::Handle<v8::Object> window = V8DOMWrapper::lookupDOMWrapper(V8DOMWindow::GetTemplate(), wrapper);
if (!window.IsEmpty())
sourceArg = V8DOMWindow::toNative(window);
}
OwnPtr<MessagePortArray> portArray;
if (!isUndefinedOrNull(args[7])) {
portArray = new MessagePortArray();
if (!getMessagePortArray(args[7], *portArray))
return v8::Undefined();
}
event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg.release(), originArg, lastEventIdArg, sourceArg, portArray.release());
return v8::Undefined();
}
void V8MessageEvent::initMessageEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
MessageEvent* event = V8MessageEvent::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
TONATIVE_VOID(bool, canBubbleArg, info[1]->BooleanValue());
TONATIVE_VOID(bool, cancelableArg, info[2]->BooleanValue());
v8::Handle<v8::Value> dataArg = info[3];
TOSTRING_VOID(V8StringResource<>, originArg, info[4]);
TOSTRING_VOID(V8StringResource<>, lastEventIdArg, info[5]);
LocalDOMWindow* sourceArg = toDOMWindow(info[6], info.GetIsolate());
OwnPtr<MessagePortArray> portArray;
const int portArrayIndex = 7;
if (!isUndefinedOrNull(info[portArrayIndex])) {
portArray = adoptPtr(new MessagePortArray);
bool success = false;
*portArray = toRefPtrNativeArray<MessagePort, V8MessagePort>(info[portArrayIndex], portArrayIndex + 1, info.GetIsolate(), &success);
if (!success)
return;
}
event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, originArg, lastEventIdArg, sourceArg, portArray.release());
if (!dataArg.IsEmpty()) {
V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::data(info.GetIsolate()), dataArg);
if (DOMWrapperWorld::current(info.GetIsolate()).isIsolatedWorld())
event->setSerializedData(SerializedScriptValue::createAndSwallowExceptions(dataArg, info.GetIsolate()));
}
}
void EchoClientHandler::messageReceived(ChannelHandlerContext& ctx, const MessageEvent& e) {
// Send back the received message to the remote peer.
//transferredBytes.addAndGet(((ChannelBuffer) e.getMessage()).readableBytes());
const ChannelBufferPtr& buffer = e.getMessage().value<ChannelBufferPtr>();
if (buffer) {
int readableBytes = buffer->readableBytes();
ChannelBufferPtr tmp = buffer->readBytes();
Channel& channel = e.getChannel();
if (intervalTime == 0) {
channel.write(tmp);
}
else {
timer->newTimeout(boost::bind(&EchoClientHandler::delaySendMessage,
this,
_1,
boost::ref(channel),
tmp),
intervalTime);
}
printf("received message from %d at %s.\n", channel.getId().intValue(), boost::posix_time::to_simple_string(boost::get_system_time()).c_str());
}
}
static JSC::JSValue handleInitMessageEvent(JSMessageEvent* jsEvent, JSC::ExecState* exec)
{
const String& typeArg = exec->argument(0).toString(exec)->value(exec);
bool canBubbleArg = exec->argument(1).toBoolean(exec);
bool cancelableArg = exec->argument(2).toBoolean(exec);
const String originArg = exec->argument(4).toString(exec)->value(exec);
const String lastEventIdArg = exec->argument(5).toString(exec)->value(exec);
DOMWindow* sourceArg = toDOMWindow(exec->argument(6));
OwnPtr<MessagePortArray> messagePorts;
OwnPtr<ArrayBufferArray> arrayBuffers;
if (!exec->argument(7).isUndefinedOrNull()) {
messagePorts = adoptPtr(new MessagePortArray);
arrayBuffers = adoptPtr(new ArrayBufferArray);
fillMessagePortArray(exec, exec->argument(7), *messagePorts, *arrayBuffers);
if (exec->hadException())
return jsUndefined();
}
ScriptValue dataArg = ScriptValue(exec->vm(), exec->argument(3));
if (exec->hadException())
return jsUndefined();
MessageEvent* event = static_cast<MessageEvent*>(jsEvent->impl());
event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, messagePorts.release());
jsEvent->m_data.set(exec->vm(), jsEvent, dataArg.jsValue());
return jsUndefined();
}
void V8MessageEvent::initMessageEventMethodCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(ExceptionState::ExecutionContext,
"initMessageEvent", "MessageEvent",
info.Holder(), info.GetIsolate());
MessageEvent* event = V8MessageEvent::toImpl(info.Holder());
TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
bool canBubbleArg = false;
bool cancelableArg = false;
if (!v8Call(info[1]->BooleanValue(info.GetIsolate()->GetCurrentContext()),
canBubbleArg) ||
!v8Call(info[2]->BooleanValue(info.GetIsolate()->GetCurrentContext()),
cancelableArg))
return;
v8::Local<v8::Value> dataArg = info[3];
TOSTRING_VOID(V8StringResource<>, originArg, info[4]);
TOSTRING_VOID(V8StringResource<>, lastEventIdArg, info[5]);
DOMWindow* sourceArg = toDOMWindow(info.GetIsolate(), info[6]);
MessagePortArray* portArray = nullptr;
const int portArrayIndex = 7;
if (!isUndefinedOrNull(info[portArrayIndex])) {
portArray = new MessagePortArray;
*portArray = toMemberNativeArray<MessagePort>(
info[portArrayIndex], portArrayIndex + 1, info.GetIsolate(),
exceptionState);
if (exceptionState.hadException())
return;
}
event->initMessageEvent(
typeArg, canBubbleArg, cancelableArg,
ScriptValue(ScriptState::current(info.GetIsolate()), dataArg), originArg,
lastEventIdArg, sourceArg, portArray);
}
bool ChannelService::EventSunk(ChannelPipeline* pipeline, MessageEvent<Buffer>& e)
{
Buffer* buffer = e.GetMessage();
RETURN_FALSE_IF_NULL(buffer);
uint32 len = buffer->ReadableBytes();
int32 ret = e.GetChannel()->WriteNow(buffer);
return ret >= 0 ? (len == (uint32) ret) : false;
}
void QCefWebView::customEvent(QEvent* e) {
//qDebug() << __FUNCTION__ << QThread::currentThreadId();
if (e->type() == MessageEvent::MessageEventType) {
MessageEvent* event = static_cast<MessageEvent*>(e);
QString name = event->name();
QVariantList args = event->args();
//qDebug() << __FUNCTION__ << name << args;
emit jsMessage(name, args);
}
}
void CtcpParser::displayMsg(NetworkEvent *event, Message::Type msgType, const QString &msg, const QString &sender,
const QString &target, Message::Flags msgFlags)
{
if (event->testFlag(EventManager::Silent))
return;
MessageEvent *msgEvent = new MessageEvent(msgType, event->network(), msg, sender, target, msgFlags);
msgEvent->setTimestamp(event->timestamp());
emit newEvent(msgEvent);
}
void EventSource::onMessageEvent(const AtomicString& eventType,
const String& data,
const AtomicString& lastEventId) {
MessageEvent* e = MessageEvent::create();
e->initMessageEvent(eventType, false, false,
SerializedScriptValue::serialize(data),
m_eventStreamOrigin, lastEventId, 0, nullptr);
InspectorInstrumentation::willDispatchEventSourceEvent(
getExecutionContext(), this, eventType, lastEventId, data);
dispatchEvent(e);
}
int TcpClient :: AddMessage(const std::string & sIP, const int iPort, const std::string & sMessage)
{
//PLImp("ok");
MessageEvent * poEvent = GetEvent(sIP, iPort);
if (poEvent == nullptr)
{
PLErr("no event created for this ip %s port %d", sIP.c_str(), iPort);
return -1;
}
return poEvent->AddMessage(sMessage);
}
void Slave::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<RedisMessage>& e)
{
if (e.GetMessage()->IsReply())
{
HandleRedisReply(ctx.GetChannel(), e.GetMessage()->reply);
}
else if (e.GetMessage()->IsCommand())
{
HandleRedisCommand(ctx.GetChannel(), e.GetMessage()->command);
}
else
{
HandleRedisDumpChunk(ctx.GetChannel(), e.GetMessage()->chunk);
}
}
v8::Handle<v8::Value> V8MessageEvent::portsAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.MessageEvent.ports");
MessageEvent* event = V8MessageEvent::toNative(info.Holder());
MessagePortArray* ports = event->ports();
if (!ports || ports->isEmpty())
return v8::Null();
v8::Local<v8::Array> portArray = v8::Array::New(ports->size());
for (size_t i = 0; i < ports->size(); ++i)
portArray->Set(v8::Integer::New(i), toV8((*ports)[i].get()));
return portArray;
}
void ClientListHandler::LIST(KIrc::Context *context, const KIrc::Message &message, KIrc::Socket *socket)
{
Q_D(ClientListHandler);
CHECK_ARGS(0, 0);
#if 0
MessageEvent *reply;
// reply.setCommand(PONG);
// reply.setArgs(msg.rawArg(0));
reply.setSuffix(msg.rawSuffix());
// msg->client->writeMessage(reply);
#endif
}
void HistoryDlg::actionOpenEvent(QTreeWidgetItem *item, int column)
{
Message m;
QString sTime;
sTime = ((DateItem*)DateTree->currentItem())->date().toString(Qt::ISODate) + "T" + item->text(1);
m.setTimeStamp(QDateTime::fromString(sTime, Qt::ISODate));
m.setFrom(jid_);
m.setType(item->text(0));
m.setBody(item->text(3));
m.setSpooled(true);
MessageEvent *me = new MessageEvent(m, 0);
me->setOriginLocal((item->text(2) == "to") ? true : false);
openEvent(me);
}
void MessageReceived(ChannelHandlerContext& ctx,
MessageEvent<Buffer>& e)
{
total_recv += (e.GetMessage()->ReadableBytes());
Buffer send(7);
send.Write("Hello\r\n", 7);
ctx.GetChannel()->Write(send);
//total_received++;
//DEBUG_LOG("Received response with total:%d", total_received);
// if (total_received == total_would_send)
// {
// ctx.GetChannel()->Close();
// ctx.GetChannel()->GetService().Stop();
// }
// else if (total_received % 2000 == 0)
// {
// //INFO_LOG("Received %d response\n", total_received);
// Buffer buf(16);
// buf.Write("Hello,world\r\n", 13);
// for (uint32 i = 0; i < 2000; i++)
// {
// if (!ctx.GetChannel()->Write(buf))
// {
// ERROR_LOG("Failed to write buf to channel with total send:%d", total_send);
// continue;
// }
// total_send++;
// buf.SetReadIndex(0);
// }
// //INFO_LOG("Write %d request\n", total_send);
// }
}
v8::Handle<v8::Value> V8MessageEvent::portsAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
MessageEvent* event = V8MessageEvent::toNative(info.Holder());
MessagePortArray* ports = event->ports();
if (!ports)
return v8::Array::New(0);
MessagePortArray portsCopy(*ports);
v8::Local<v8::Array> portArray = v8::Array::New(portsCopy.size());
for (size_t i = 0; i < portsCopy.size(); ++i)
portArray->Set(v8Integer(i, info.GetIsolate()), toV8(portsCopy[i].get(), info.Holder(), info.GetIsolate()));
return portArray;
}
void Master::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<RedisCommandFrame>& e)
{
RedisCommandFrame* cmd = e.GetMessage();
DEBUG_LOG("Master recv cmd from slave:%s", cmd->ToString().c_str());
if (!strcasecmp(cmd->GetCommand().c_str(), "replconf"))
{
if (cmd->GetArguments().size() == 2 && !strcasecmp(cmd->GetArguments()[0].c_str(), "ack"))
{
int64 offset;
if (string_toint64(cmd->GetArguments()[1], offset))
{
SlaveConnTable::iterator found = m_slaves.find(ctx.GetChannel()->GetID());
if (found != m_slaves.end())
{
SlaveConn* slave = found->second;
if (NULL != slave)
{
slave->acktime = time(NULL);
slave->ack_offset = offset;
}
}
}
}
}
}
JSValue* jsMessageEventPrototypeFunctionInitMessageEvent(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSMessageEvent::s_info))
return throwError(exec, TypeError);
JSMessageEvent* castedThisObj = static_cast<JSMessageEvent*>(thisValue);
MessageEvent* imp = static_cast<MessageEvent*>(castedThisObj->impl());
const UString& typeArg = args[0]->toString(exec);
bool canBubbleArg = args[1]->toBoolean(exec);
bool cancelableArg = args[2]->toBoolean(exec);
const UString& dataArg = args[3]->toString(exec);
const UString& originArg = args[4]->toString(exec);
const UString& lastEventIdArg = args[5]->toString(exec);
DOMWindow* sourceArg = toDOMWindow(args[6]);
imp->initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg);
return jsUndefined();
}
bool RedisCommandEncoder::WriteRequested(ChannelHandlerContext& ctx, MessageEvent<RedisCommandFrame>& e)
{
RedisCommandFrame* msg = e.GetMessage();
if (Encode(ctx.GetChannel()->GetOutputBuffer(), *msg))
{
ctx.GetChannel()->EnableWriting();
return true;
}
return false;
}
void MessageReceived(ChannelHandlerContext& ctx,
MessageEvent<Buffer>& e)
{
Buffer* input = e.GetMessage();
if (m_cumulation.Readable())
{
m_cumulation.DiscardReadedBytes();
m_cumulation.Write(input, input->ReadableBytes());
CallDecode(ctx, e.GetChannel(), m_cumulation);
} else
{
CallDecode(ctx, e.GetChannel(), *input);
if (input->Readable())
{
m_cumulation.Write(input, input->ReadableBytes());
}
}
}
bool RedisCommandEncoder::WriteRequested(ChannelHandlerContext& ctx, MessageEvent<RedisCommandFrame>& e)
{
RedisCommandFrame* msg = e.GetMessage();
m_buffer.Clear();
if (Encode(m_buffer, *msg))
{
return ctx.GetChannel()->Write(m_buffer);
}
return false;
}
void V8MessageEvent::dataAttributeGetterCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
ScriptState* scriptState = ScriptState::current(info.GetIsolate());
auto privateCachedData =
V8PrivateProperty::getMessageEventCachedData(info.GetIsolate());
v8::Local<v8::Value> cachedData =
privateCachedData.get(scriptState->context(), info.Holder());
if (!cachedData.IsEmpty()) {
v8SetReturnValue(info, cachedData);
return;
}
MessageEvent* event = V8MessageEvent::toImpl(info.Holder());
v8::Local<v8::Value> result;
switch (event->getDataType()) {
case MessageEvent::DataTypeScriptValue:
result = event->dataAsScriptValue().v8ValueFor(scriptState);
if (result.IsEmpty())
result = v8::Null(info.GetIsolate());
break;
case MessageEvent::DataTypeSerializedScriptValue:
if (SerializedScriptValue* serializedValue =
event->dataAsSerializedScriptValue()) {
MessagePortArray ports = event->ports();
result = serializedValue->deserialize(info.GetIsolate(), &ports);
} else {
result = v8::Null(info.GetIsolate());
}
break;
case MessageEvent::DataTypeString:
result = v8String(info.GetIsolate(), event->dataAsString());
break;
case MessageEvent::DataTypeBlob:
result = toV8(event->dataAsBlob(), info.Holder(), info.GetIsolate());
break;
case MessageEvent::DataTypeArrayBuffer:
result =
toV8(event->dataAsArrayBuffer(), info.Holder(), info.GetIsolate());
break;
}
// Store the result as a private value so this callback returns the cached
// result in future invocations.
privateCachedData.set(scriptState->context(), info.Holder(), result);
v8SetReturnValue(info, result);
}
JSC::JSValue JSMessageEvent::initMessageEvent(JSC::ExecState* exec, const JSC::ArgList& args)
{
const UString& typeArg = args.at(0).toString(exec);
bool canBubbleArg = args.at(1).toBoolean(exec);
bool cancelableArg = args.at(2).toBoolean(exec);
PassRefPtr<SerializedScriptValue> dataArg = SerializedScriptValue::create(exec, args.at(3));
const UString& originArg = args.at(4).toString(exec);
const UString& lastEventIdArg = args.at(5).toString(exec);
DOMWindow* sourceArg = toDOMWindow(args.at(6));
OwnPtr<MessagePortArray> messagePorts;
if (!args.at(7).isUndefinedOrNull()) {
messagePorts = new MessagePortArray();
fillMessagePortArray(exec, args.at(7), *messagePorts);
if (exec->hadException())
return jsUndefined();
}
MessageEvent* event = static_cast<MessageEvent*>(this->impl());
event->initMessageEvent(ustringToAtomicString(typeArg), canBubbleArg, cancelableArg, dataArg, ustringToString(originArg), ustringToString(lastEventIdArg), sourceArg, messagePorts.release());
return jsUndefined();
}
JSValue JSMessageEvent::data(ExecState* exec) const
{
if (JSValue cachedValue = m_data.get())
return cachedValue;
MessageEvent* event = static_cast<MessageEvent*>(impl());
JSValue result;
switch (event->dataType()) {
case MessageEvent::DataTypeSerializedScriptValue:
if (SerializedScriptValue* serializedValue = event->dataAsSerializedScriptValue())
result = serializedValue->deserialize(exec, globalObject(), NonThrowing);
else
result = jsNull();
break;
case MessageEvent::DataTypeString:
result = jsString(exec, event->dataAsString());
break;
case MessageEvent::DataTypeBlob:
result = toJS(exec, globalObject(), event->dataAsBlob());
break;
case MessageEvent::DataTypeArrayBuffer:
result = toJS(exec, globalObject(), event->dataAsArrayBuffer());
break;
}
// Save the result so we don't have to deserialize the value again.
const_cast<JSMessageEvent*>(this)->m_data.set(exec->globalData(), this, result);
return result;
}
v8::Handle<v8::Value> V8MessageEvent::dataAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.MessageEvent.data");
MessageEvent* event = V8MessageEvent::toNative(info.Holder());
v8::Handle<v8::Value> result;
switch (event->dataType()) {
case MessageEvent::DataTypeSerializedScriptValue:
if (SerializedScriptValue* serializedValue = event->dataAsSerializedScriptValue())
result = serializedValue->deserialize();
else
result = v8::Null();
break;
case MessageEvent::DataTypeString: {
String stringValue = event->dataAsString();
result = v8::String::New(fromWebCoreString(stringValue), stringValue.length());
break;
}
case MessageEvent::DataTypeBlob:
result = toV8(event->dataAsBlob());
break;
case MessageEvent::DataTypeArrayBuffer:
result = toV8(event->dataAsArrayBuffer());
break;
}
// Overwrite the data attribute so it returns the cached result in future invocations.
// This custom handler (dataAccessGetter) will not be called again.
v8::PropertyAttribute dataAttr = static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly);
info.Holder()->ForceSet(name, result, dataAttr);
return result;
}
void Console::customEvent ( QEvent * event )
{
if ( event->type() == MessageEvent::eventClassType() )
{
MessageEvent * me = (MessageEvent*) event;
if ( me->isCustomCharFormatSet() )
append( me->message(), me->msgType(), me->charFormat() );
else
append( me->message(), me->msgType() );
}
}
