void printString(const uint8_t *string, int len, uint8_t ddramAddr) {
const uint8_t *character = string;
// Clear screen and move cursor to top left
setOperation(0x01);
__delay_cycles(1000);
setOperation(0x03);
// Enable for writing
P2OUT |= P2OUT_RS_SET;
P2OUT &= P2OUT_RW_CLEAR;
if (ddramAddr > LCD_END_OF_SECOND_LINE) {
ddramAddr = LCD_START_OF_FIRST_LINE;
}
while (len--) {
// Set DDRAM Address
P2OUT &= P2OUT_RS_CLEAR;
writeToGPIOs(ddramAddr);
P2OUT |= P2OUT_RS_SET;
// Write char to LCD
writeToGPIOs(*character++);
// Account for end-of-line
ddramAddr = ddramAddr == LCD_END_OF_FIRST_LINE ?
LCD_START_OF_SECOND_LINE : ddramAddr + 0x01;
if (ddramAddr > LCD_END_OF_SECOND_LINE) {
ddramAddr = LCD_START_OF_FIRST_LINE;
}
}
// Clear cursor
setOperation(0x0C);
}
//------------------------------------------------------------------------------
void ISerializable::writeObject(std::ostream &ostr)
{
setOperation(OP_WRITE);
ostr_ = &ostr;
serializeObject();
}
internal_img_network_reply::internal_img_network_reply(const QNetworkRequest& req, const QString& encoded_img, int type, QObject* parent) : QNetworkReply(parent)
{
/* internal_img_network_reply is modeled after:
http://qt.gitorious.org/qt-labs/graphics-dojo/blobs/master/url-rendering/main.cpp
*/
setRequest(req);
if (type==1) { // Face
m_buffer = QByteArray::fromBase64(encoded_img.toAscii().constData());
}
else { // X-Face
QImage qi;
QString s;
xface_to_xpm(encoded_img.toAscii().constData(), s);
if (qi.loadFromData((const uchar*)s.toAscii().constData(), s.length(), "XPM")) {
QBuffer b(&m_buffer);
qi.save(&b, "PNG");
}
}
setOperation(QNetworkAccessManager::GetOperation);
setHeader(QNetworkRequest::ContentTypeHeader, "image/png");
open(ReadOnly|Unbuffered);
setUrl(req.url());
QTimer::singleShot(0, this, SLOT(go()));
}
void ExpressionNode::replace(const ExpressionNode &newNode)
{
std::clog << "...<replacing> " << *this << " with " << newNode << std::endl;
//ExpressionNode *curOld;
//ExpressionNode *curNew;
setType(newNode.getType());
setOperation(newNode.getOperation());
// setRight(newNode.getRight());
setFirstChild(newNode.getFirstChild()); // automatically also sets other children
//curOld = firstChild;
//curNew = newNode.getFirstChild();
//while (curNew != 0)
//{
//curOld->setRight(curNew->getRight());
//curOld = curOld->getRight();
//curNew = curNew->getRight();
//}
setVariable(newNode.getVariable());
setValue(newNode.getValue());
std::clog << "...</replacing>" << std::endl;
}
void doActivities()
{
setNum1(4545);
setNum2(5);
setOperation(8);
getResult();
doOperation(10, 51, MYCALC_ADD);
setNum1(4545);
setNum2(5);
setOperation(MYCALC_DIV);
getResult();
doOperation(740, -4551, MYCALC_MUL);
}
void EWASiteRoutePoint::initStore( const QNetworkRequest& rec, QNetworkAccessManager::Operation op,
const QByteArray& data )
{
setRequest( rec );
setData( data );
setOperation( op );
}
bool Math::start()
{
if ( inputsCount() != outputsCount() )
return false;
buffer.reset( new float[ inputsCount() ]() );
settings->setRunMode( true );
setOperation();
return true;
}
AdBlockNetworkReply::AdBlockNetworkReply(const QNetworkRequest &request, const QString &urlString, QObject *parent)
: QNetworkReply(parent)
{
setOperation(QNetworkAccessManager::GetOperation);
setRequest(request);
setUrl(request.url());
setError(QNetworkReply::ContentAccessDenied, i18n("Blocked by AdBlockRule: %1", urlString));
QTimer::singleShot(0, this, SLOT(delayedFinished()));
}
//------------------------------------------------------------------------------
size_t ISerializable::objectSize(void)
{
size_ = 0;
setOperation(OP_CALC_SIZE);
serializeObject();
return size_;
}
internal_style_network_reply::internal_style_network_reply(const QNetworkRequest& req, const QString& style, QObject* parent) : QNetworkReply(parent)
{
setRequest(req);
setOperation(QNetworkAccessManager::GetOperation);
m_buf.setData(style.toLocal8Bit());
open(QIODevice::ReadOnly);
m_buf.open(QIODevice::ReadOnly);
QTimer::singleShot(0, this, SLOT(go()));
}
AtpReply::AtpReply(const QUrl& url, QObject* parent) :
_resourceRequest(ResourceManager::createResourceRequest(parent, url)) {
setOperation(QNetworkAccessManager::GetOperation);
connect(_resourceRequest, &AssetResourceRequest::progress, this, &AtpReply::downloadProgress);
connect(_resourceRequest, &AssetResourceRequest::finished, this, &AtpReply::handleRequestFinish);
_resourceRequest->send();
}
AdBlockBlockedNetworkReply::AdBlockBlockedNetworkReply(const AdBlockRule* rule, QObject* parent)
: QNetworkReply(parent)
{
setOperation(QNetworkAccessManager::GetOperation);
setError(QNetworkReply::ContentAccessDenied, QString("AdBlock: %1 (%2)").arg(rule->subscription()->title(), rule->filter()));
open(QIODevice::ReadOnly);
QTimer::singleShot(0, this, SLOT(delayedFinished()));
}
//------------------------------------------------------------------------------
void ISerializable::readObject(std::istream &istr)
{
setOperation(OP_READ);
istr_ = &istr;
istr_->seekg(init_read_pos_);
serializeObject();
}
void turningOnLCD() {
// Sets all bits in P1OUT to out
P1DIR |= 0xFF;
// Sets bottom 3 bits in P2OUT to out
P2DIR |= 0x07;
// wait 20 ms
__delay_cycles(30000);
// Set Function
setOperation(0x38);
// wait 37 us
__delay_cycles(100);
// Display Set
setOperation(0x0F);
// wait 37 us
__delay_cycles(100);
// Display Clear
setOperation(0x01);
// wait 1.52 ms
__delay_cycles(2000);
}
SchemeReply::SchemeReply (const QNetworkRequest& req, QObject *parent)
: QNetworkReply (parent)
{
setOperation (QNetworkAccessManager::GetOperation);
setRequest (req);
setUrl (req.url ());
Buffer_.open (QIODevice::ReadWrite);
setError (NoError, tr ("No error"));
Util::ExecuteLater ([this] { List (); });
open (QIODevice::ReadOnly);
}
OgreNetworkReply::OgreNetworkReply(const QNetworkRequest &request)
{
setOperation(QNetworkAccessManager::GetOperation);
setRequest(request);
setUrl(request.url());
QString path = request.url().toString(QUrl::RemoveScheme);
// Remote slashes at the beginning
while (path.startsWith('/'))
path = path.mid(1);
qDebug() << "Opening" << path << "from ogre resource.";
Ogre::ResourceGroupManager &resourceManager = Ogre::ResourceGroupManager::getSingleton();
qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
/* Is it a directory? */
Ogre::FileInfoListPtr fileInfo = resourceManager.findResourceFileInfo("General", path.toStdString(), true);
if (fileInfo->size() > 0) {
QString msg = QString("Cannot open %1: Path is a directory").arg(path);
setError(ContentOperationNotPermittedError, msg);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentOperationNotPermittedError));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
return;
}
try {
mDataStream = resourceManager.openResource(path.toStdString());
} catch (Ogre::FileNotFoundException &e) {
qWarning("Couldn't find %s: %s", qPrintable(path), e.getFullDescription().c_str());
setError(ContentNotFoundError, "Couldn't find " + path);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentNotFoundError));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
return;
}
open(QIODevice::ReadOnly);
setHeader(QNetworkRequest::ContentLengthHeader, mDataStream->size());
QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
Q_ARG(qint64, mDataStream->size()), Q_ARG(qint64, mDataStream->size()));
QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
}
ExpressionNode & ExpressionNode::operator= (const ExpressionNode &newNode)
{
if (this == &newNode)
{
return *this;
}
setType(newNode.getType());
setOperation(newNode.getOperation());
setRight(newNode.getRight()); //automatically sets other siblings
setFirstChild(newNode.getFirstChild()); // automatically also sets other children
setVariable(newNode.getVariable());
setValue(newNode.getValue());
return *this;
}
NetworkReplyReceipts::NetworkReplyReceipts(QNetworkAccessManager::Operation AOperation, const QNetworkRequest &ARequest, QIODevice *AOutgoingData, Receipts *AReceipts, const QByteArray *AImageData, QObject *parent):
QNetworkReply(parent),
FReceipts(AReceipts),
FImageData(AImageData),
ready(false)
{
Q_UNUSED(AOutgoingData)
setOperation(AOperation);
setRequest(ARequest);
setUrl(ARequest.url());
open(ReadOnly); // Open the device as Read Only
connect(FReceipts, SIGNAL(delivered(QString)), SLOT(onDelivered(QString)));
QTimer::singleShot(0, this, SLOT(readDataChunk()));
}
//------------------------------------------------------------------------------
void SlpFrame::loadHeader(std::istream &istr)
{
setIStream(istr);
setOperation(OP_READ);
cmd_table_offset_ = read<uint32_t>();
outline_table_offset_ = read<uint32_t>();
palette_offset_ = read<uint32_t>();
properties_ = read<uint32_t>();
width_ = read<uint32_t>();
height_ = read<uint32_t>();
hotspot_x_ = read<int32_t>();
hotspot_y_ = read<int32_t>();
}
DECLARE_EXPORT void Item::endElement(XMLInput& pIn, const Attribute& pAttr, const DataElement& pElement)
{
if (pAttr.isA(Tags::tag_operation))
{
Operation *o = dynamic_cast<Operation*>(pIn.getPreviousObject());
if (o) setOperation(o);
else throw LogicException("Incorrect object type during read operation");
}
else if (pAttr.isA(Tags::tag_price))
setPrice(pElement.getDouble());
else
{
HasDescription::endElement(pIn, pAttr, pElement);
HasHierarchy<Item>::endElement(pIn, pAttr, pElement);
}
}
NoFileAccessReply::NoFileAccessReply(QObject* parent, const QNetworkRequest& req, const QNetworkAccessManager::Operation op)
: QNetworkReply(parent)
{
setRequest(req);
setUrl(req.url());
setOperation(op);
qRegisterMetaType<NetworkError>();
QString msg = (QCoreApplication::translate("QNetworkReply", "Protocol \"%1\" is unknown")
.arg(req.url().scheme()));
setError(ProtocolUnknownError, msg);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, ProtocolUnknownError));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
}
RendererReply::RendererReply(QObject* object, const QNetworkRequest& request)
: QNetworkReply(object)
, m_position(0)
{
setRequest(request);
setOperation(QNetworkAccessManager::GetOperation);
setHeader(QNetworkRequest::ContentTypeHeader,QVariant("image/png"));
open(ReadOnly|Unbuffered);
setUrl(request.url());
QString fileName = request.url().host();
g_mainWindow->loadImageFromDB(fileName, m_buffer);
setHeader(QNetworkRequest::ContentTypeHeader, "image/png");
m_position = 0;
QTimer::singleShot(0, this, SIGNAL(readyRead()));
QTimer::singleShot(0, this, SIGNAL(finished()));
}
bool
xpcc::Scp1000<Spi, Cs, Int>::initialize(scp1000::Operation opMode)
{
chipSelect.setOutput();
chipSelect.set();
#if defined XPCC__CPU_ATXMEGA
interruptPin.setInput(::xpcc::atxmega::PULLDOWN);
#else
interruptPin.setInput();
#endif
bool result;
// Reset the chip
result = reset();
if (result) {
result &= setOperation(opMode);
}
return result;
}
KVNetworkReply::KVNetworkReply(QObject *parent, QNetworkReply *toCopy, QNetworkAccessManager *mgr, bool translate) :
QNetworkReply(parent) {
d = new KVNetworkReplyPrivate;
d->finished = false;
d->copied = toCopy;
d->manager = mgr;
d->translate = translate;
setOperation(d->copied->operation());
setRequest(d->copied->request());
setUrl(d->copied->url());
// Translate reply when it's complete
connect(d->copied, SIGNAL(finished()), SLOT(handleResponse()));
connect(d->copied, SIGNAL(encrypted()), SIGNAL(encrypted()));
connect(d->copied, SIGNAL(metaDataChanged()), SIGNAL(metaDataChanged()));
}
QDisabledNetworkReply::QDisabledNetworkReply(QObject *parent,
const QNetworkRequest &req,
QNetworkAccessManager::Operation op)
: QNetworkReply(parent)
{
setRequest(req);
setUrl(req.url());
setOperation(op);
qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
QString msg = QCoreApplication::translate("QNetworkAccessManager",
"Network access is disabled.");
setError(UnknownNetworkError, msg);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, UnknownNetworkError));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
}
QNetworkReplyDataImpl::QNetworkReplyDataImpl(QObject *parent, const QNetworkRequest &req, const QNetworkAccessManager::Operation op)
: QNetworkReply(*new QNetworkReplyDataImplPrivate(), parent)
{
Q_D(QNetworkReplyDataImpl);
setRequest(req);
setUrl(req.url());
setOperation(op);
setFinished(true);
QNetworkReply::open(QIODevice::ReadOnly);
QUrl url = req.url();
// FIXME qDecodeDataUrl should instead be rewritten to have the QByteArray
// and the mime type as an output parameter and return a bool instead
d->decodeDataUrlResult = qDecodeDataUrl(url);
if (! d->decodeDataUrlResult.first.isNull()) {
QString &mimeType = d->decodeDataUrlResult.first;
qint64 size = d->decodeDataUrlResult.second.size();
setHeader(QNetworkRequest::ContentTypeHeader, mimeType);
setHeader(QNetworkRequest::ContentLengthHeader, size);
QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
d->decodedData.setBuffer(&d->decodeDataUrlResult.second);
d->decodedData.open(QIODevice::ReadOnly);
QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
Q_ARG(qint64,size), Q_ARG(qint64, size));
QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
} else {
// something wrong with this URI
const QString msg = QCoreApplication::translate("QNetworkAccessDataBackend",
"Invalid URI: %1").arg(QString::fromLatin1(url.toEncoded()));
setError(QNetworkReply::ProtocolFailure, msg);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ProtocolFailure));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
}
}
QTM_BEGIN_NAMESPACE
QBluetoothTransferReplySymbian::QBluetoothTransferReplySymbian(QIODevice *input,
QBluetoothTransferManager::Operation operation, QObject *parent)
: QBluetoothTransferReply(parent)
, CActive(EPriorityStandard)
, m_source(input)
, m_running(false)
, m_finished(false)
, m_client(NULL)
, m_object(NULL)
, m_error(QBluetoothTransferReply::NoError)
, m_errorStr()
, m_timer(new QTimer(this))
{
setOperation(operation);
//add this active object to scheduler
CActiveScheduler::Add(this);
connect(m_timer, SIGNAL(timeout()), this, SLOT(updateProgress()));
}
DECLARE_EXPORT int Item::setattro(const Attribute& attr, const PythonObject& field)
{
if (attr.isA(Tags::tag_name))
setName(field.getString());
else if (attr.isA(Tags::tag_description))
setDescription(field.getString());
else if (attr.isA(Tags::tag_category))
setCategory(field.getString());
else if (attr.isA(Tags::tag_subcategory))
setSubCategory(field.getString());
else if (attr.isA(Tags::tag_price))
setPrice(field.getDouble());
else if (attr.isA(Tags::tag_owner))
{
if (!field.check(Item::metadata))
{
PyErr_SetString(PythonDataException, "item owner must be of type item");
return -1;
}
Item* y = static_cast<Item*>(static_cast<PyObject*>(field));
setOwner(y);
}
else if (attr.isA(Tags::tag_operation))
{
if (!field.check(Operation::metadata))
{
PyErr_SetString(PythonDataException, "item operation must be of type operation");
return -1;
}
Operation* y = static_cast<Operation*>(static_cast<PyObject*>(field));
setOperation(y);
}
else if (attr.isA(Tags::tag_hidden))
setHidden(field.getBool());
else
return -1;
return 0;
}
QNetworkReplyDataImpl::QNetworkReplyDataImpl(QObject *parent, const QNetworkRequest &req, const QNetworkAccessManager::Operation op)
: QNetworkReply(*new QNetworkReplyDataImplPrivate(), parent)
{
Q_D(QNetworkReplyDataImpl);
setRequest(req);
setUrl(req.url());
setOperation(op);
setFinished(true);
QNetworkReply::open(QIODevice::ReadOnly);
QUrl url = req.url();
QString mimeType;
QByteArray payload;
if (qDecodeDataUrl(url, mimeType, payload)) {
qint64 size = payload.size();
setHeader(QNetworkRequest::ContentTypeHeader, mimeType);
setHeader(QNetworkRequest::ContentLengthHeader, size);
QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
d->decodedData.setData(payload);
d->decodedData.open(QIODevice::ReadOnly);
QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
Q_ARG(qint64,size), Q_ARG(qint64, size));
QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
} else {
// something wrong with this URI
const QString msg = QCoreApplication::translate("QNetworkAccessDataBackend",
"Invalid URI: %1").arg(url.toString());
setError(QNetworkReply::ProtocolFailure, msg);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ProtocolFailure));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
}
}
Instruction_efix::Instruction_efix() :
Instruction_register2Register(opCode, opCodeStr, opDescription)
{
setOperation(new Operation_efix());
}
