status_t String8::append(const String8& other)
{
const size_t otherLen = other.bytes();
if (bytes() == 0) {
setTo(other);
return NO_ERROR;
} else if (otherLen == 0) {
return NO_ERROR;
}
return real_append(other.string(), otherLen);
}
/* `step1ab()` gets rid of plurals, `-ed`, `-ing`.
*
* Such as:
*
* caresses -> caress
* ponies -> poni
* ties -> ti
* caress -> caress
* cats -> cat
*
* feed -> feed
* agreed -> agree
* disabled -> disable
*
* matting -> mat
* mating -> mate
* meeting -> meet
* milling -> mill
* messing -> mess
*
* meetings -> meet
*/
static void
step1ab() {
int character;
if (b[k] == 's') {
if (ends("\04" "sses")) {
k -= 2;
} else if (ends("\03" "ies")) {
setTo("\01" "i");
} else if (b[k - 1] != 's') {
k--;
}
}
if (ends("\03" "eed")) {
if (getMeasure() > 0) {
k--;
}
} else if ((ends("\02" "ed") || ends("\03" "ing")) && vowelInStem()) {
k = j;
if (ends("\02" "at")) {
setTo("\03" "ate");
} else if (ends("\02" "bl")) {
setTo("\03" "ble");
} else if (ends("\02" "iz")) {
setTo("\03" "ize");
} else if (isDoubleConsonant(k)) {
k--;
character = b[k];
if (character == 'l' || character == 's' || character == 'z') {
k++;
}
} else if (getMeasure() == 1 && cvc(k)) {
setTo("\01" "e");
}
}
}
void ParticleParameter::parseFromTokens(parser::DefTokeniser& tok)
{
std::string val = tok.nextToken();
try
{
setFrom(boost::lexical_cast<float>(val));
}
catch (boost::bad_lexical_cast&)
{
rError() << "[particles] Bad lower value, token is '" <<
val << "'" << std::endl;
}
if (tok.peek() == "to")
{
// Upper value is there, parse it
tok.skipTokens(1); // skip the "to"
val = tok.nextToken();
try
{
// cut off the quotes before converting to double
setTo(boost::lexical_cast<float>(val));
}
catch (boost::bad_lexical_cast&)
{
rError() << "[particles] Bad upper value, token is '" <<
val << "'" << std::endl;
}
}
else
{
setTo(getFrom());
}
}
void RoomCLEntry::SendDirectedStatus (const EntryStatus& state, const QString&)
{
auto conn = Account_->GetClientConnection ();
auto pres = XooxUtil::StatusToPresence (state.State_,
state.StatusString_, conn->GetLastState ().Priority_);
pres.setTo (RH_->GetRoomJID ());
const auto discoMgr = conn->GetClient ()->findExtension<QXmppDiscoveryManager> ();
pres.setCapabilityHash ("sha-1");
pres.setCapabilityNode (discoMgr->clientCapabilitiesNode ());
pres.setCapabilityVer (discoMgr->capabilities ().verificationString ());
conn->GetClient ()->sendPacket (pres);
}
void Period::changePart(int s)
{
if(!type) { addSecs(s*secs()); return; }
uint np = type->parts.size();
if(np)
{
uint p = (part + np + s)%np;
if(part == 0 && s < 0) add(t1, type->base, -1);
if(part == np - 1 && s > 0) add(t1, type->base, 1);
part = p;
QDateTime dt = set(from(), type->base, type->parts[part]);
setFrom(dt); setTo(dt);
p = (part + 1)%np;
if(part == np - 1) add(t2, type->base, 1);
setTo(set(to(), type->base, type->parts[p]));
}
else
{
setFrom(set(from(), type->base));
add(t1, type->base, s);
t2 = t1;
add(t2, type->base, 1);
}
}
void PerspectiveCamera::load(const QString &filename)
{
FILE *fp=fopen(filename.toStdString().c_str(),"rb");
float sfov=0;
float sfarPlane=0;
float snearPlane=0;
GGL::Point3f sfrom;
GGL::Point3f sto;
GGL::Point3f sup;
fread(&sfov,sizeof(float),1,fp);
qDebug("fov:%f",sfov);
fread(&sfarPlane,sizeof(float),1,fp);
qDebug("far plane:%f",sfarPlane);
fread(&snearPlane,sizeof(float),1,fp);
qDebug("near plane:%f",snearPlane);
float vsfrom[3];
fread(vsfrom,sizeof(float),3,fp);
qDebug("from:%f,%f,%f",vsfrom[0],vsfrom[1],vsfrom[2]);
float vsto[3];
fread(vsto,sizeof(float),3,fp);
qDebug("to:%f,%f,%f",vsto[0],vsto[1],vsto[2]);
float vsup[3];
fread(vsup,sizeof(float),3,fp);
qDebug("up:%f,%f,%f",vsup[0],vsup[1],vsup[2]);
fclose(fp);
setFov(sfov);
setFarPlane(sfarPlane);
setNearPlane(snearPlane);
setFrom(GGL::Point3f(vsfrom[0],vsfrom[1],vsfrom[2]));
setTo(GGL::Point3f(vsto[0],vsto[1],vsto[2]));
setUp(GGL::Point3f(vsup[0],vsup[1],vsup[2]));
}
void EntryBase::SendDirectedStatus (const EntryStatus& state, const QString& variant)
{
if (!CanSendDirectedStatusNow (variant))
return;
auto conn = Account_->GetClientConnection ();
auto pres = XooxUtil::StatusToPresence (state.State_,
state.StatusString_, conn->GetLastState ().Priority_);
QString to = GetJID ();
if (!variant.isEmpty ())
to += '/' + variant;
pres.setTo (to);
auto discoMgr = conn->GetClient ()->findExtension<QXmppDiscoveryManager> ();
pres.setCapabilityHash ("sha-1");
pres.setCapabilityNode (discoMgr->clientCapabilitiesNode ());
pres.setCapabilityVer (discoMgr->capabilities ().verificationString ());
conn->GetClient ()->sendPacket (pres);
}
bool JabberChatService::sendRawMessage(const Chat &chat, const QByteArray &rawMessage)
{
if (!m_client)
return false;
auto jid = m_resourceService->bestChatJid(chat);
if (jid.isEmpty())
return false;
auto xmppMessage = QXmppMessage{};
xmppMessage.setBody(rawMessage);
xmppMessage.setFrom(m_client.data()->clientPresence().id());
xmppMessage.setStamp(QDateTime::currentDateTime());
xmppMessage.setTo(jid.full());
xmppMessage.setType(chatMessageType(chat, jid.bare()));
m_client.data()->sendPacket(m_chatStateService->withSentChatState(xmppMessage));
return true;
}
status_t String16::append(const char16_t* chrs, size_t otherLen)
{
const size_t myLen = size();
if (myLen == 0) {
setTo(chrs, otherLen);
return NO_ERROR;
} else if (otherLen == 0) {
return NO_ERROR;
}
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
->editResize((myLen+otherLen+1)*sizeof(char16_t));
if (buf) {
char16_t* str = (char16_t*)buf->data();
memcpy(str+myLen, chrs, otherLen*sizeof(char16_t));
str[myLen+otherLen] = 0;
mString = str;
return NO_ERROR;
}
return NO_MEMORY;
}
void Stopwatch::clientMessage(QJsonObject msg, int id)
{
if(msg.contains("start")){
start(false);
emit started();
sendMsgButNotTo(msg,id,true);
}
if(msg.contains("stop")){
stop(false);
emit stoped();
sendMsgButNotTo(msg,id,true);
}
if(msg.contains("resume")){
resume(false);
emit resumed();
sendMsgButNotTo(msg,id,true);
}
if(msg.contains("set")){
setTo((long)msg.value("set").toDouble(),false);
emit timeSet();
sendMsgButNotTo(msg,id,true);
}
}
void SimpleMoveComponent::moveTo(CCPoint to)
{
CCPoint pos=((CCNode*)m_pOwner)->getPosition();
float dx=to.x-pos.x;
float dy=to.y-pos.y;
CCLOG("moveTo:%f,%f, diff:%f,%f",to.x,to.y,dx,dy);
if(dx>0 || dy>0){
float s=sqrtf(dx*dx+dy*dy);
float directionX=dx/s;
float directionY=dy/s;
m_directionFlagX=dx>0?1:dx<0?-1:0;
m_directionFlagY=dy>0?1:dy<0?-1:0;
setTo(to);
moveWithDirection(directionX, directionY,true);
}
}
AString::AString(const char *s, size_t size)
: mData(NULL),
mSize(0),
mAllocSize(1) {
setTo(s, size);
}
AString::AString(const char *s)
: mData(NULL),
mSize(0),
mAllocSize(1) {
setTo(s);
}
UMat& UMat::operator = (const Scalar& s)
{
setTo(s);
return *this;
}
Session::Session(Type type, const QString &fileName)
: Session()
{
setTo(type, fileName);
}
Session &Session::operator=(const Session &other)
{
setTo(other.type(), other.fileName());
return *this;
}
void AString::setTo(const char *s) {
setTo(s, strlen(s));
}
void
AssetManagerGlue::Theme::copyTheme(const AssetManagerGlue::Theme& src)
{
setTo(src);
}
inline
GpuMat& GpuMat::setTo(Scalar s)
{
return setTo(s, Stream::Null());
}
status_t String16::setTo(const char16_t* other)
{
return setTo(other, strlen16(other));
}
String16::String16(const String16& o, size_t len, size_t begin)
: mString(getEmptyString())
{
setTo(o, len, begin);
}
ThemeMetadata::ThemeMetadata(const QString &path, QObject *parent) : QObject(parent), d(new ThemeMetadataPrivate()) {
setTo(path);
}
AString::AString(const AString &from)
: mData(NULL),
mSize(0),
mAllocSize(1) {
setTo(from, 0, from.size());
}
JingleStanza::JingleStanza(const Jid &AFrom, const Jid &ATo, const QString &ASid, IJingle::Action AAction):
Stanza("iq"), jingle(addElement("jingle", NS_JINGLE))
{
QString action;
switch (AAction)
{
case IJingle::SessionInitiate:
action="session-initiate";
break;
case IJingle::SessionAccept:
action="session-accept";
break;
case IJingle::SessionTerminate:
action="session-terminate";
break;
case IJingle::SessionInfo:
action="session-info";
break;
case IJingle::ScurityInfo:
action="security-info";
break;
case IJingle::DescriptionInfo:
action="description-info";
break;
case IJingle::ContentAdd:
action="content-add";
break;
case IJingle::ContentModify:
action="content-modify";
break;
case IJingle::ContentAccept:
action="content-accept";
break;
case IJingle::ContentReject:
action="content-reject";
break;
case IJingle::ContentRemove:
action="content-remove";
break;
case IJingle::TransportAccept:
action="transport-accept";
break;
case IJingle::TransportInfo:
action="transport-info";
break;
case IJingle::TransportReject:
action="transport-reject";
break;
case IJingle::TransportReplace:
action="transport-replace";
break;
default:
return;
}
setType("set");
setFrom(AFrom.full());
setTo(ATo.full());
setId(QString("id%1").arg(QDateTime::currentDateTime().toTime_t(),0,16));
jingle.setAttribute("action", action);
jingle.setAttribute("sid", ASid);
}
AString::AString(const AString &from, size_t offset, size_t n)
: mData(NULL),
mSize(0),
mAllocSize(1) {
setTo(from, offset, n);
}
void STileEdit::mouseMoveEvent(QMouseEvent *e)
{
if (mIsMouseDown && !mShift && mContext->mCurrentMap && mContext->mCurrentMap->getWorkingLayer() && !mCtrl)
{
mStartPos = e->pos();
vec3 pos = mContext->camera.screenToWorld(vec3{(F32)e->x(), (F32)e->y(), 1.0f});
if (pos(0) >= 0 && pos(0) < mContext->mCurrentMap->getTileWidth() * mContext->mCurrentMap->getWidth()
&& pos(1) >= 0 && pos(1) < mContext->mCurrentMap->getTileHeight() * mContext->mCurrentMap->getHeight())
{
if ( !(mCurrentSelection.first == "NULL") )
{
if (mStartNewHistoryItem)
{
emit mContext->sig_updateHistoryMacro(mStartNewHistoryItem);
mStartNewHistoryItem = false;
}
emit mContext->sig_addUndoCommand(new CInsertTiles(mContext->mCurrentMap, mContext->mCurrentMap->getTiles(mCurrentSelection.second,
GData::getInstance()->getManager()->GetTexture(mCurrentSelection.first)),
iPnt(pos(0) / mContext->mCurrentMap->getTileWidth(), pos(1) / mContext->mCurrentMap->getTileHeight()),
mCurrentSelection.second));
}
mContext->update();
}
}
else if (mIsMouseDown && mShift && !mCtrl)
{
vec3 currentMousePos = vec3(e->x(), e->y(), 1.0f);
vec3 dmouse = mContext->camera.screenToWorld(currentMousePos) - mContext->camera.screenToWorld(mPreviousMousePos);
mContext->camera.box().setPosition(mContext->camera.box().getPosition() - dmouse);
mContext->camera.update(0);
mPreviousMousePos = currentMousePos;
mContext->update();
}
// show transparent selection under mouse
if ( !(mCurrentSelection.first == "NULL"))
{
I32 tW = mContext->mCurrentMap->getTileWidth();
I32 tH = mContext->mCurrentMap->getTileHeight();
if (mSelectionRender.size() > 0)
{
I32 greatestX = 0;
I32 greatestY = 0;
I32 smallestX = 100000;
I32 smallestY = 100000;
I32 greatestXIndex = 0;
I32 greatestYIndex = 0;
I32 smallestXIndex = 0;
I32 smallestYIndex = 0;
I32 count = 0;
for (const auto& pnt : mCurrentSelection.second)
{
if (pnt.x() > greatestX)
{
greatestX = pnt.x();
greatestXIndex = count;
}
if (pnt.y() > greatestY)
{
greatestY = pnt.y();
greatestYIndex = count;
}
if (pnt.x() < smallestX)
{
smallestX = pnt.x();
smallestXIndex = pnt.x();
}
if (pnt.y() < smallestY)
{
smallestY = pnt.y();
smallestYIndex = pnt.y();
}
++count;
}
for (const auto& pnt : mCurrentSelection.second)
{
vec3 setTo(e->x(), e->y(), 1.0f);
setTo = mContext->camera.screenToWorld(setTo);
setTo[0] -= (I32)setTo(0) % tW - (0.5f * tW);
setTo[1] -= (I32)setTo(1) % tH - (0.5f * tH);
setTo[0] += (pnt.x() - smallestX) * tW;
setTo[1] += (pnt.y() - smallestY) * tH;
setTo[0] = (I32)setTo(0);
setTo[1] = (I32)setTo(1);
mSelectionRender[ (pnt.y() - smallestY) * (greatestX - smallestX + 1) + (pnt.x() - smallestX)].box().setPosition(setTo);
mSelectionRender[ (pnt.y() - smallestY) * (greatestX - smallestX + 1) + (pnt.x() - smallestX)].box().updateVertsPosition();
}
mContext->update();
}
}
}
void AString::setTo(const AString &from, size_t offset, size_t n) {
CHECK(&from != this);
clear();
setTo(from.mData + offset, n);
}
/* Set string. */
static void
replace(const char *value) {
if (getMeasure() > 0) {
setTo(value);
}
}
inline
GpuMat& GpuMat::setTo(Scalar s, InputArray mask)
{
return setTo(s, mask, Stream::Null());
}
void SimpleCamera::setTarget(const PVRTVec3& vec)
{
PVRTVec3 vActual = m_vPosition - vec;
setTo(vActual);
}
