TupProjectCommand::TupProjectCommand(TupCommandExecutor *executor, const TupProjectRequest *request) : QUndoCommand(), k(new Private())
{
#ifdef K_DEBUG
T_FUNCINFO;
#endif
k->executor = executor;
k->executed = false;
TupRequestParser parser;
if (!parser.parse(request->xml())) {
#ifdef K_DEBUG
tFatal() << "TupProjectCommand::TupProjectCommand(): - Parser error!";
#endif
}
k->response = parser.response();
k->response->setExternal(request->isExternal());
if (!k->response) {
#ifdef K_DEBUG
tFatal() << "TupProjectCommand::TupProjectCommand() - Unparsed response!";
#endif
}
initText();
}
/**
* This function loads a local library
*/
void TupProject::loadLibrary(const QString &filename)
{
#ifdef K_DEBUG
#ifdef Q_OS_WIN
qDebug() << "[TupProject::loadLibrary()]";
#else
T_FUNCINFO;
#endif
#endif
QFile file(filename);
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
k->library->fromXml(QString::fromLocal8Bit(file.readAll()));
file.close();
} else {
#ifdef K_DEBUG
QString msg = "TupProject::loadLibrary() - Cannot open library from: " + filename;
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tFatal("library") << msg;
#endif
#endif
}
}
TMultiplexingServer *TMultiplexingServer::instance()
{
if (!multiplexingServer) {
tFatal("Call TMultiplexingServer::instantiate() function first");
}
return multiplexingServer;
}
bool TupCommandExecutor::insertSymbolIntoFrame(TupLibraryResponse *response)
{
#ifdef K_DEBUG
tFatal() << "TupCommandExecutor::insertSymbolIntoFrame() - Adding symbol to project: " << response->arg().toString();
#endif
if (m_project->scenesTotal() > 0) {
if (m_project->insertSymbolIntoFrame(response->spaceMode(), response->arg().toString(),
response->sceneIndex(), response->layerIndex(), response->frameIndex())) {
TupScene *scene = m_project->scene(response->sceneIndex());
if (scene) {
TupLayer *layer = scene->layer(response->layerIndex());
if (layer) {
TupFrame *frame = layer->frame(response->frameIndex());
if (frame)
response->setFrameState(frame->isEmpty());
}
}
emit responsed(response);
return true;
}
} else {
#ifdef K_DEBUG
tError() << "TupCommandExecutor::insertSymbolIntoFrame() - No scenes available!";
#endif
}
return false;
}
void TupExposureHeader::mousePressEvent(QMouseEvent *event)
{
int section = logicalIndexAt(event->pos());
if (section > -1 && section < count()) {
int x = sectionViewportPosition(section) + 3;
QFont font = this->font();
font.setPointSize(8);
QFontMetrics fm(font);
QString text = m_sections[section].title;
int w = fm.width(text);
int limit = sectionSize(section)/2 - w/2;
QRect rect(x + limit - 12, 3, 12, height()-3);
if (rect.contains(event->pos())) {
notifyVisibilityChange(section);
} else {
if (m_currentSection != section)
emit headerSelectionChanged(section);
QHeaderView::mousePressEvent(event);
}
} else {
#ifdef K_DEBUG
QString msg = "TupExposureHeader::mousePressEvent() - Fatal Error: Section index is invalid -> " + QString::number(section);
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tFatal() << msg;
#endif
#endif
}
}
void TupTimeLine::sceneResponse(TupSceneResponse *response)
{
Q_UNUSED(response);
#ifdef K_DEBUG
#ifdef Q_OS_WIN32
qDebug() << "[TupTimeLine::sceneResponse()]";
#else
T_FUNCINFO;
#endif
#endif
switch (response->action()) {
case TupProjectRequest::Add:
{
insertScene(response->sceneIndex(), response->arg().toString());
}
break;
case TupProjectRequest::Remove:
{
removeScene(response->sceneIndex());
}
break;
case TupProjectRequest::Move:
{
}
break;
case TupProjectRequest::Lock:
{
}
break;
case TupProjectRequest::Rename:
{
}
break;
case TupProjectRequest::Select:
{
k->container->setCurrentIndex(response->sceneIndex());
}
break;
default:
#ifdef K_DEBUG
QString msg = "TupTimeLine::sceneResponse : Unknown action :/";
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal() << msg;
#endif
#endif
break;
}
}
void TupGraphicsScene::addSvgObject(TupSvgItem *svgItem, double opacity)
{
#ifdef K_DEBUG
T_FUNCINFO;
#endif
if (svgItem) {
k->onionSkin.opacityMap.insert(svgItem, opacity);
svgItem->setSelected(false);
TupLayer *layer = k->scene->layer(k->framePosition.layer);
if (layer) {
TupFrame *frame = layer->frame(k->framePosition.frame);
if (frame) {
svgItem->setOpacity(opacity);
if (svgItem->symbolName().compare("dollar.svg")==0)
connect(svgItem, SIGNAL(enabledChanged()), this, SIGNAL(showInfoWidget()));
addItem(svgItem);
} else {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::addSvgObject() - Error: Frame #" << k->framePosition.frame << " NO available!";
#endif
}
} else {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::addSvgObject() - Error: Layer #" << k->framePosition.layer << " NO available!";
#endif
}
} else {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::addSvgObject() - Error: No SVG item!";
#endif
}
}
bool TupItemTweener::contains(TupItemTweener::Type type)
{
// tError() << "TupItemTweener::contains() - Type List Size: " << k->tweenList.size();
for (int i=0; i < k->tweenList.size(); i++) {
tFatal() << "TupItemTweener::contains() - type: " << k->tweenList.at(i);
if (k->tweenList.at(i) == type)
return true;
}
return false;
}
TupFrame *TupGraphicsScene::currentFrame()
{
if (k->scene) {
if (k->scene->layersTotal() > 0) {
if (k->framePosition.layer < k->scene->layersTotal()) {
if (k->scene->layers().contains(k->framePosition.layer)) {
TupLayer *layer = k->scene->layer(k->framePosition.layer);
Q_CHECK_PTR(layer);
if (layer) {
if (!layer->frames().isEmpty())
return layer->frame(k->framePosition.frame);
} else {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::currentFrame - No layer available: " << k->framePosition.frame;
#endif
}
} else {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::currentFrame - Layer index incorrect!";
#endif
}
} else {
TupLayer *layer = k->scene->layer(k->scene->layersTotal() - 1);
if (layer) {
if (!layer->frames().isEmpty())
return layer->frame(k->framePosition.frame);
}
}
}
}
return 0;
}
bool TupCommandExecutor::createSymbol(TupLibraryResponse *response)
{
#ifdef K_DEBUG
tFatal() << "TupCommandExecutor::createSymbol() - Creating object: " << response->arg().toString();
#endif
if (m_project->createSymbol(response->symbolType(), response->arg().toString(),
response->data(), response->parent())) {
emit responsed(response);
return true;
}
return false;
}
bool TupXmlParserBase::fatalError(const QXmlParseException & exception)
{
#ifdef K_DEBUG
#ifdef Q_OS_WIN32
QString msg1 = exception.lineNumber() + QString("x") + exception.columnNumber() + QString(": ") + exception.message();
qDebug() << msg1;
#else
tFatal() << exception.lineNumber() << "x" << exception.columnNumber() << ": " << exception.message();
tWarning() << __PRETTY_FUNCTION__ << " Document: " << k->document;
#endif
#else
Q_UNUSED(exception);
#endif
return true;
}
void TupFramesTable::emitFrameSelected(QTableWidgetItem *current, QTableWidgetItem *prev)
{
Q_UNUSED(prev);
TupFramesTableItem *item = dynamic_cast<TupFramesTableItem *>(current);
if (item) {
if (item->isUsed())
emit emitRequestChangeFrame(k->sceneIndex, verticalHeader()->visualIndex(this->row(item)), this->column(item));
// emit frameRequest(TupProjectActionBar::SelectFrame, this->column(item), verticalHeader()->visualIndex(this->row(item)), -1);
else
tFatal() << "TupFramesTable::emitFrameSelected <- item exists but isn't used right now";
} else {
emit frameRequest(TupProjectActionBar::InsertFrame, currentColumn(), currentRow(), k->sceneIndex);
}
}
void TupGraphicsScene::mouseReleased(QGraphicsSceneMouseEvent *event)
{
#ifdef K_DEBUG
T_FUNCINFO;
#endif
if (k->tool->toolType() == TupToolInterface::Brush) {
if (event->button() == Qt::RightButton) {
return;
}
}
if (currentFrame()) {
if (currentFrame()->isLocked()) {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::mouseReleased() - Frame is locked!";
#endif
return;
}
}
k->inputInformation->updateFromMouseEvent(event);
if (k->isDrawing) {
if (k->tool) {
k->tool->release(k->inputInformation, k->brushManager, this);
k->tool->end();
}
} else {
if (k->tool) {
if (k->tool->name().compare(tr("Zoom In")) == 0 || k->tool->name().compare(tr("Zoom Out")) == 0) {
if (event->button() != Qt::RightButton)
k->tool->release(k->inputInformation, k->brushManager, this);
}
}
}
k->isDrawing = false;
}
TAbstractWebSocket *TAbstractWebSocket::searchWebSocket(int sid)
{
TAbstractWebSocket *sock = nullptr;
switch ( Tf::app()->multiProcessingModule() ) {
case TWebApplication::Thread:
sock = TWebSocket::searchSocket(sid);
break;
case TWebApplication::Hybrid: {
#ifdef Q_OS_LINUX
sock = TEpollWebSocket::searchSocket(sid);
#else
tFatal("Unsupported MPM: hybrid");
#endif
break; }
default:
break;
}
return sock;
}
TupProjectResponse *TupProjectResponseFactory::create(int part, int action)
{
switch (part) {
case TupProjectRequest::Scene:
{
return new TupSceneResponse(part, action);
}
break;
case TupProjectRequest::Layer:
{
return new TupLayerResponse(part, action);
}
break;
case TupProjectRequest::Frame:
{
return new TupFrameResponse(part, action);
}
break;
case TupProjectRequest::Item:
{
return new TupItemResponse(part, action);
}
break;
case TupProjectRequest::Library:
{
return new TupLibraryResponse(part, action);
}
break;
default:
{
tFatal() << "TupProjectResponseFactory::create() - Unknown/Unhandled element: " << part;
}
break;
}
return new TupProjectResponse(part, action);
}
void TupGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
#ifdef K_DEBUG
T_FUNCINFO;
#endif
QGraphicsScene::mousePressEvent(event);
k->inputInformation->updateFromMouseEvent(event);
k->isDrawing = false;
// This condition locks all the tools while workspace is rotated
if ((event->buttons() != Qt::LeftButton) || (event->modifiers () != (Qt::ShiftModifier | Qt::ControlModifier))) {
if (k->tool) {
if (k->tool->toolType() == TupToolPlugin::Brush && event->isAccepted())
return;
if (k->tool->toolType() == TupToolPlugin::Tweener && event->isAccepted()) {
tFatal() << "TupGraphicsScene::mousePressEvent() - Tracing!";
if (k->tool->currentEditMode() == TupToolPlugin::Path)
return;
}
// If there's no frame... the tool is disabled
if (currentFrame()) {
//if (event->buttons() == Qt::LeftButton && !currentFrame()->isLocked()) {
//tFatal() << "TupGraphicsScene::mousePressEvent() - FLAG: " << currentFrame()->isLocked();
if (event->buttons() == Qt::LeftButton) {
k->tool->begin();
k->isDrawing = true;
k->tool->press(k->inputInformation, k->brushManager, this);
}
}
}
}
}
bool TupProject::insertSymbolIntoFrame(TupProject::Mode spaceMode, const QString &name, int sceneIndex,
int layerIndex, int frameIndex)
{
#ifdef K_DEBUG
#ifdef Q_OS_WIN
qDebug() << "[TupProject::insertSymbolIntoFrame()]";
#else
T_FUNCINFO;
#endif
#endif
TupFrame *frame = 0;
TupScene *scene = this->sceneAt(sceneIndex);
if (scene) {
if (spaceMode == TupProject::FRAMES_EDITION) {
TupLayer *layer = scene->layerAt(layerIndex);
if (layer)
frame = layer->frameAt(frameIndex);
else
return false;
} else if (spaceMode == TupProject::STATIC_BACKGROUND_EDITION) {
TupBackground *bg = scene->background();
if (bg)
frame = bg->staticFrame();
else
return false;
} else if (spaceMode == TupProject::DYNAMIC_BACKGROUND_EDITION) {
TupBackground *bg = scene->background();
if (bg)
frame = bg->dynamicFrame();
else
return false;
} else {
#ifdef K_DEBUG
QString msg = "TupProject::insertSymbolIntoFrame() - Fatal Error: invalid spaceMode!";
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tError() << msg;
#endif
#endif
return false;
}
if (frame) {
TupLibraryObject *object = k->library->getObject(name);
if (object) {
switch (object->type()) {
case TupLibraryObject::Item:
{
TupGraphicLibraryItem *libraryItem = new TupGraphicLibraryItem(object);
int zLevel = frame->getTopZLevel();
libraryItem->setZValue(zLevel);
frame->addLibraryItem(name, libraryItem);
}
break;
case TupLibraryObject::Image:
{
TupGraphicLibraryItem *libraryItem = new TupGraphicLibraryItem(object);
int imageW = libraryItem->boundingRect().width();
int imageH = libraryItem->boundingRect().height();
if (k->dimension.width() > imageW && k->dimension.height() > imageH)
libraryItem->moveBy((k->dimension.width() - imageW)/2, (k->dimension.height() - imageH)/2);
else
libraryItem->moveBy(0, 0);
int zLevel = frame->getTopZLevel();
libraryItem->setZValue(zLevel);
frame->addItem(name, libraryItem);
}
break;
case TupLibraryObject::Svg:
{
QString path(object->dataPath());
TupSvgItem *svgItem = new TupSvgItem(path, frame);
svgItem->setSymbolName(name);
int svgW = svgItem->boundingRect().width();
int svgH = svgItem->boundingRect().height();
if (k->dimension.width() > svgW && k->dimension.height() > svgH) {
svgItem->moveBy((k->dimension.width() - svgW)/2, (k->dimension.height() - svgH)/2);
} else {
qreal factorW = ((qreal)k->dimension.width())/((qreal)svgW);
qreal factorH = ((qreal)k->dimension.height())/((qreal)svgH);
if (factorW < factorH)
svgItem->setScale(factorW);
else
svgItem->setScale(factorH);
svgItem->moveBy(0, 0);
}
int zLevel = frame->getTopZLevel();
svgItem->setZValue(zLevel);
frame->addSvgItem(name, svgItem);
}
break;
case TupLibraryObject::Text:
{
// SQA: Just out of curiosity, check if this case really happens!
// tFatal() << "TupProject::insertSymbolIntoFrame() - Just tracing text!";
TupGraphicLibraryItem *libraryItem = new TupGraphicLibraryItem(object);
int zLevel = frame->getTopZLevel();
libraryItem->setZValue(zLevel);
frame->addItem(name, libraryItem);
}
break;
case TupLibraryObject::Sound:
{
TupSoundLayer *sound = scene->createSoundLayer(scene->soundLayers().count());
sound->fromSymbol(object->symbolName());
}
break;
default:
#ifdef K_DEBUG
QString msg = "TupProject::insertSymbolIntoFrame() -> Unknown Object Type";
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tFatal() << msg;
#endif
#endif
break;
}
return true;
} else {
#ifdef K_DEBUG
QString msg = "TupProject::insertSymbolIntoFrame() - Object NOT found at library! " + name;
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tError() << msg;
#endif
#endif
return false;
}
} else {
#ifdef K_DEBUG
QString msg = "TupProject::insertSymbolIntoFrame() - Invalid frame!";
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tError() << msg;
#endif
#endif
}
} else {
#ifdef K_DEBUG
QString msg = "TupProject::insertSymbolIntoFrame() - Invalid scene!";
#ifdef Q_OS_WIN
qDebug() << msg;
#else
tError() << msg;
#endif
#endif
}
return false;
}
void TupGraphicsScene::addSvgTweeningObjects(int photogram)
{
QList<TupSvgItem *> svgList = k->scene->tweeningSvgObjects();
for (int i=0; i < svgList.count(); i++) {
TupSvgItem *object = svgList.at(i);
if (object->frame()->layer()->isVisible()) {
int origin = object->frame()->index();
if (TupItemTweener *tween = object->tween()) {
int adjustX = object->boundingRect().width()/2;
int adjustY = object->boundingRect().height()/2;
if (origin == photogram) {
TupTweenerStep *stepItem = tween->stepAt(0);
object->setToolTip(tween->tweenType() + ": " + tween->name() + tr("/Step: 0"));
if (stepItem->has(TupTweenerStep::Position)) {
object->setPos(tween->transformOriginPoint());
QPointF offset = QPoint(-adjustX, -adjustY);
object->setLastTweenPos(stepItem->position() + offset);
}
if (stepItem->has(TupTweenerStep::Rotation)) {
double angle = stepItem->rotation();
object->setTransformOriginPoint(tween->transformOriginPoint());
object->setRotation(angle);
}
if (stepItem->has(TupTweenerStep::Scale)) {
QPointF point = tween->transformOriginPoint();
object->setTransformOriginPoint(point);
object->setScale(1.0);
}
if (stepItem->has(TupTweenerStep::Shear)) {
QTransform transform;
transform.shear(0, 0);
object->setTransform(transform);
}
if (stepItem->has(TupTweenerStep::Opacity))
object->setOpacity(stepItem->opacity());
} else if ((origin < photogram) && (photogram < origin + tween->frames())) {
int step = photogram - origin;
TupTweenerStep *stepItem = tween->stepAt(step);
object->setToolTip(tween->tweenType() + ": " + tween->name() + tr("/Step: ") + QString::number(step));
if (stepItem->has(TupTweenerStep::Position)) {
qreal dx = stepItem->position().x() - (object->lastTweenPos().x() + adjustX);
qreal dy = stepItem->position().y() - (object->lastTweenPos().y() + adjustY);
object->moveBy(dx, dy);
QPointF offset = QPoint(-adjustX, -adjustY);
object->setLastTweenPos(stepItem->position() + offset);
}
if (stepItem->has(TupTweenerStep::Rotation)) {
double angle = stepItem->rotation();
object->setRotation(angle);
}
if (stepItem->has(TupTweenerStep::Scale)) {
QPointF point = tween->transformOriginPoint();
double scaleX = stepItem->horizontalScale();
double scaleY = stepItem->verticalScale();
QTransform transform;
transform.translate(point.x(), point.y());
transform.scale(scaleX, scaleY);
transform.translate(-point.x(), -point.y());
object->setTransform(transform);
}
if (stepItem->has(TupTweenerStep::Shear)) {
QPointF point = tween->transformOriginPoint();
double shearX = stepItem->horizontalShear();
double shearY = stepItem->verticalShear();
QTransform transform;
transform.translate(point.x(), point.y());
transform.shear(shearX, shearY);
transform.translate(-point.x(), -point.y());
object->setTransform(transform);
}
addSvgObject(object);
if (stepItem->has(TupTweenerStep::Opacity))
object->setOpacity(stepItem->opacity());
}
} else {
#ifdef K_DEBUG
tFatal() << "TupGraphicsScene::addSvgTweeningObjects() - No tween found!";
#endif
}
}
}
}
void TWebSocketWorker::execute(int opcode, const QByteArray &payload)
{
bool sendTask = false;
QString es = TUrlRoute::splitPath(_requestPath).value(0).toLower() + "endpoint";
TDispatcher<TWebSocketEndpoint> dispatcher(es);
TWebSocketEndpoint *endpoint = dispatcher.object();
if (!endpoint) {
return;
}
try {
tSystemDebug("Found endpoint: %s", qPrintable(es));
tSystemDebug("TWebSocketWorker opcode: %d", opcode);
endpoint->sessionStore = _socket->session(); // Sets websocket session
endpoint->sid = _socket->socketId();
auto peerInfo = TApplicationServerBase::getPeerInfo(_socket->socketDescriptor());
endpoint->peerAddr = peerInfo.first;
endpoint->peerPortNumber = peerInfo.second;
// Database Transaction
setTransactionEnabled(endpoint->transactionEnabled());
switch (_mode) {
case Opening: {
bool res = endpoint->onOpen(_httpSession);
if (res) {
// For switch response
endpoint->taskList.prepend(qMakePair((int)TWebSocketEndpoint::OpenSuccess, QVariant()));
if (endpoint->keepAliveInterval() > 0) {
endpoint->startKeepAlive(endpoint->keepAliveInterval());
}
} else {
endpoint->taskList.prepend(qMakePair((int)TWebSocketEndpoint::OpenError, QVariant()));
}
break; }
case Closing:
if (!_socket->closing.exchange(true)) {
endpoint->onClose(Tf::GoingAway);
endpoint->unsubscribeFromAll();
}
break;
case Receiving: {
switch (opcode) {
case TWebSocketFrame::TextFrame:
endpoint->onTextReceived(QString::fromUtf8(payload));
break;
case TWebSocketFrame::BinaryFrame:
endpoint->onBinaryReceived(payload);
break;
case TWebSocketFrame::Close: {
quint16 closeCode = Tf::GoingAway;
if (payload.length() >= 2) {
QDataStream ds(payload);
ds.setByteOrder(QDataStream::BigEndian);
ds >> closeCode;
}
if (!_socket->closing.exchange(true)) {
endpoint->onClose(closeCode);
endpoint->unsubscribeFromAll();
}
endpoint->close(closeCode); // close response or disconnect
break; }
case TWebSocketFrame::Ping:
endpoint->onPing(payload);
break;
case TWebSocketFrame::Pong:
endpoint->onPong(payload);
break;
default:
tSystemWarn("Invalid opcode: 0x%x [%s:%d]", (int)opcode, __FILE__, __LINE__);
break;
}
break; }
default:
break;
}
// Sets session to the websocket
_socket->setSession(endpoint->session());
for (auto &p : (const QList<QPair<int, QVariant>> &)endpoint->taskList) {
const QVariant &taskData = p.second;
tSystemDebug("WebSocket Task: %d", p.first);
switch (p.first) {
case TWebSocketEndpoint::OpenSuccess:
_socket->sendHandshakeResponse();
break;
case TWebSocketEndpoint::OpenError:
_socket->closing = true;
_socket->closeSent = true;
_socket->disconnect();
goto open_error;
break;
case TWebSocketEndpoint::SendText:
_socket->sendText(taskData.toString());
sendTask = true;
break;
case TWebSocketEndpoint::SendBinary:
_socket->sendBinary(taskData.toByteArray());
sendTask = true;
break;
case TWebSocketEndpoint::SendClose:
if (_socket->closing.load() && _socket->closeSent.load()) {
// close-frame sent and received
_socket->disconnect();
} else {
uint closeCode = taskData.toUInt();
_socket->sendClose(closeCode);
sendTask = true;
}
break;
case TWebSocketEndpoint::SendPing:
_socket->sendPing(taskData.toByteArray());
sendTask = true;
break;
case TWebSocketEndpoint::SendPong:
_socket->sendPong(taskData.toByteArray());
sendTask = true;
break;
case TWebSocketEndpoint::SendTextTo: {
QVariantList lst = taskData.toList();
TAbstractWebSocket *websocket = TAbstractWebSocket::searchWebSocket(lst[0].toInt());
if (websocket) {
websocket->sendText(lst[1].toString());
}
break; }
case TWebSocketEndpoint::SendBinaryTo: {
QVariantList lst = taskData.toList();
TAbstractWebSocket *websocket = TAbstractWebSocket::searchWebSocket(lst[0].toInt());
if (websocket) {
websocket->sendBinary(lst[1].toByteArray());
}
break; }
case TWebSocketEndpoint::SendCloseTo: {
QVariantList lst = taskData.toList();
TAbstractWebSocket *websocket = TAbstractWebSocket::searchWebSocket(lst[0].toInt());
if (websocket) {
websocket->sendClose(lst[1].toInt());
}
break; }
case TWebSocketEndpoint::Subscribe: {
QVariantList lst = taskData.toList();
TPublisher::instance()->subscribe(lst[0].toString(), lst[1].toBool(), _socket);
break; }
case TWebSocketEndpoint::Unsubscribe:
TPublisher::instance()->unsubscribe(taskData.toString(), _socket);
break;
case TWebSocketEndpoint::UnsubscribeFromAll:
TPublisher::instance()->unsubscribeFromAll(_socket);
break;
case TWebSocketEndpoint::PublishText: {
QVariantList lst = taskData.toList();
TPublisher::instance()->publish(lst[0].toString(), lst[1].toString(), _socket);
break; }
case TWebSocketEndpoint::PublishBinary: {
QVariantList lst = taskData.toList();
TPublisher::instance()->publish(lst[0].toString(), lst[1].toByteArray(), _socket);
break; }
case TWebSocketEndpoint::StartKeepAlive:
_socket->startKeepAlive(taskData.toInt());
break;
case TWebSocketEndpoint::StopKeepAlive:
_socket->stopKeepAlive();
break;
case TWebSocketEndpoint::HttpSend: {
QVariantList lst = taskData.toList();
auto id = lst[0].toInt();
switch ( Tf::app()->multiProcessingModule() ) {
case TWebApplication::Thread: {
auto *sock = THttpSocket::searchSocket(id);
if (sock) {
sock->writeRawDataFromWebSocket(lst[1].toByteArray());
}
break; }
case TWebApplication::Hybrid: {
#ifdef Q_OS_LINUX
auto *sock = TEpollHttpSocket::searchSocket(id);
if (sock) {
sock->sendData(lst[1].toByteArray());
}
#else
tFatal("Unsupported MPM: hybrid");
#endif
break; }
default:
break;
}
break; }
default:
tSystemError("Invalid logic [%s:%d]", __FILE__, __LINE__);
break;
}
}
if (!sendTask) {
// Receiving but not sending, so renew keep-alive
_socket->renewKeepAlive();
}
open_error:
// transaction
if (Q_UNLIKELY(endpoint->rollbackRequested())) {
rollbackTransactions();
} else {
// Commits a transaction to the database
commitTransactions();
}
} catch (ClientErrorException &e) {
bool TupXmlParserBase::fatalError(const QXmlParseException & exception)
{
tFatal() << exception.lineNumber() << "x" << exception.columnNumber() << ": " << exception.message();
tWarning() << __PRETTY_FUNCTION__ << " Document: " << k->document;
return true;
}
void TupTimeLine::requestCommand(int action)
{
int scenePos = k->container->currentIndex();
if (scenePos < 0) {
#ifdef K_DEBUG
QString msg = "TupTimeLine::requestCommand() - Fatal Error: Scene index is invalid -> " + QString::number(scenePos);
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal("timeline") << msg;
#endif
#endif
return;
}
int layerPos = framesTable(scenePos)->currentLayer();
if (layerPos < 0) {
#ifdef K_DEBUG
QString msg = "TupTimeLine::requestCommand() - Fatal Error: Layer index is invalid -> " + QString::number(layerPos);
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal("timeline") << msg;
#endif
#endif
return;
}
int framePos = framesTable(scenePos)->lastFrameByLayer(layerPos);
if (framePos < 0) {
#ifdef K_DEBUG
QString msg = "TupTimeLine::requestCommand() - Fatal Error: Frame index is invalid -> " + QString::number(framePos);
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal("timeline") << msg;
#endif
#endif
return;
}
if (TupProjectActionBar::FrameActions & action) {
if (!requestFrameAction(action, framePos, layerPos, scenePos)) {
#ifdef K_DEBUG
QString msg = "TupTimeLine::requestCommand() - Fatal Error: Frame action has failed!";
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal("timeline") << msg;
#endif
#endif
}
return;
}
if (TupProjectActionBar::LayerActions & action) {
if (!requestLayerAction(action, layerPos, scenePos)) {
#ifdef K_DEBUG
QString msg = "TupTimeLine::requestCommand() - Fatal Error: Layer action has failed!";
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal("timeline") << msg;
#endif
#endif
}
return;
}
if (TupProjectActionBar::SceneActions & action) {
if (!requestSceneAction(action, scenePos)) {
#ifdef K_DEBUG
QString msg = "TupTimeLine::requestCommand() - Fatal Error: Scene action has failed!";
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal("timeline") << msg;
#endif
#endif
}
return;
}
}
void TupPaintArea::mousePressEvent(QMouseEvent *event)
{
#ifdef K_DEBUG
T_FUNCINFO;
#endif
// SQA: Temporal solution for cases when there's no current frame defined
if (!graphicsScene()->currentFrame()) {
return;
}
if (graphicsScene()->currentFrame()->isLocked()) {
#ifdef K_DEBUG
tFatal() << "TupPaintArea::mousePressEvent() - Frame is locked!";
#endif
return;
}
if (k->currentTool.compare(tr("Line Selection")) == 0) {
// If a node is the target... abort!
if (event->buttons() == Qt::RightButton) {
if (qgraphicsitem_cast<TControlNode *>(scene()->itemAt(mapToScene(event->pos()))))
return;
}
}
if (k->currentTool.compare(tr("Object Selection")) == 0) {
if (event->buttons() == Qt::RightButton) {
// If a node is the target... abort!
if (qgraphicsitem_cast<Node *>(scene()->itemAt(mapToScene(event->pos()))))
return;
if (QGraphicsItem *item = scene()->itemAt(mapToScene(event->pos()))) {
if (item->opacity() == 1) {
item->setFlag(QGraphicsItem::ItemIsSelectable, true);
item->setSelected(true);
} else {
return;
}
}
QMenu *menu = new QMenu(tr("Drawing area"));
menu->addAction(kApp->findGlobalAction("undo"));
menu->addAction(kApp->findGlobalAction("redo"));
menu->addSeparator();
QAction *cut = menu->addAction(tr("Cut"), this, SLOT(cutItems()), QKeySequence(tr("Ctrl+X")));
QAction *copy = menu->addAction(tr("Copy"), this, SLOT(copyItems()), QKeySequence(tr("Ctrl+C")));
QAction *paste = menu->addAction(tr("Paste"), this, SLOT(pasteItems()), QKeySequence(tr("Ctrl+V")));
QAction *del = menu->addAction(tr("Delete"), this, SLOT(deleteItems()), QKeySequence(Qt::Key_Delete));
menu->addSeparator();
QMenu *order = new QMenu(tr("Order"));
connect(order, SIGNAL(triggered(QAction*)), this, SLOT(requestMoveSelectedItems(QAction*)));
order->addAction(tr("Send to back"))->setData(MoveBack);
order->addAction(tr("Bring to front"))->setData(MoveFront);
order->addAction(tr("Send backwards"))->setData(MoveBackwards);
order->addAction(tr("Brind forwards"))->setData(MoveForwards);
menu->addMenu(order);
order->setDisabled(true);
menu->addSeparator();
// Code commented temporary while SQA is done
QAction *addItem = menu->addAction(tr("Add to library..."), this, SLOT(addSelectedItemsToLibrary()));
menu->addSeparator();
if (scene()->selectedItems().isEmpty()) {
del->setEnabled(false);
cut->setEnabled(false);
copy->setEnabled(false);
addItem->setEnabled(false);
} else {
QList<QGraphicsItem *> selected = scene()->selectedItems();
foreach (QGraphicsItem *item, selected) {
QDomDocument dom;
dom.appendChild(dynamic_cast<TupAbstractSerializable *>(item)->toXml(dom));
QDomElement root = dom.documentElement();
if (root.tagName() == "symbol") {
QString key = root.attribute("id").toUpper();
if (key.endsWith("JPG") || key.endsWith("PNG") || key.endsWith("GIF") || key.endsWith("XPM")) {
addItem->setEnabled(false);
break;
}
} else if (root.tagName() == "svg") {
addItem->setEnabled(false);
break;
}
}
}
if (k->copiesXml.isEmpty())
paste->setEnabled(false);
if (QMenu *toolMenu = graphicsScene()->currentTool()->menu()) {
menu->addSeparator();
menu->addMenu(toolMenu);
}
k->position = viewPosition();
k->menuOn = true;
menu->exec(event->globalPos());
}
}
bool TupPaletteParser::startTag(const QString &tag, const QXmlAttributes &atts)
{
if (root() == "Palette") {
if (tag == root()) {
k->paletteName = atts.value("name");
if (atts.value("editable") == "true")
k->isEditable = true;
else
k->isEditable = false;
} else if (tag == "Color") {
QColor c = QColor(atts.value("colorName"));
c.setAlpha( atts.value("alpha").toInt() );
if (c.isValid()) {
k->brushes << c;
} else {
#ifdef K_DEBUG
QString msg = "TupPaletteParser::startTag() - Error: Invalid color!";
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tError() << msg;
#endif
#endif
}
} else if (tag == "Gradient") {
if (k->gradient)
delete k->gradient;
k->gradient = 0;
k->gradientStops.clear();
QGradient::Type type = QGradient::Type(atts.value("type").toInt());
QGradient::Spread spread = QGradient::Spread(atts.value("spread").toInt());
switch (type) {
case QGradient::LinearGradient:
{
k->gradient = new QLinearGradient(atts.value("startX").toDouble(),
atts.value("startY").toDouble(),atts.value("finalX").toDouble(),
atts.value("finalY").toDouble());
}
break;
case QGradient::RadialGradient:
{
k->gradient = new QRadialGradient(atts.value("centerX").toDouble(),
atts.value("centerY").toDouble(), atts.value("radius").toDouble(),
atts.value("focalX").toDouble(),atts.value("focalY").toDouble() );
}
break;
case QGradient::ConicalGradient:
{
k->gradient = new QConicalGradient(atts.value("centerX").toDouble(),
atts.value("centerY").toDouble(),atts.value("angle").toDouble());
}
break;
default:
{
#ifdef K_DEBUG
QString msg = "TupPaletteParser::startTag() - No gradient type: " + QString::number(type);
#ifdef Q_OS_WIN32
qDebug() << msg;
#else
tFatal() << msg;
#endif
#endif
}
break;
}
k->gradient->setSpread(spread);
} else if (tag == "Stop") {
QColor c(atts.value("colorName") );
c.setAlpha(atts.value("alpha").toInt());
// k->gradientStops << qMakePair(atts.value("value").toDouble(), c);
k->gradientStops << qMakePair((qreal)(atts.value("value").toDouble()), c);
}
}
return true;
}
