SonicXNFile::SonicXNFile(XNFileMode file_mode_parameter) {
info=NULL;
offset_table=NULL;
footer=NULL;
end=NULL;
big_endian=false;
file_mode = file_mode_parameter;
setHeaders();
// Create Essential Sections
info = new SonicXNInfo();
info->setHeader(header_info);
info->setFileMode(file_mode);
info->setBigEndian(big_endian);
offset_table = new SonicXNOffsetTable();
offset_table->setHeader(LIBGENS_XNSECTION_HEADER_OFFSET_TABLE);
offset_table->setFileMode(file_mode);
offset_table->setBigEndian(big_endian);
footer=new SonicXNFooter();
footer->setHeader(LIBGENS_XNSECTION_HEADER_FOOTER);
footer->setFileMode(file_mode);
footer->setBigEndian(big_endian);
end=new SonicXNEnd();
end->setHeader(LIBGENS_XNSECTION_HEADER_END);
end->setFileMode(file_mode);
end->setBigEndian(big_endian);
}
void ZipArch::open()
{
setHeaders();
m_buffer = "";
m_header_removed = false;
m_finished = false;
KProcess *kp = m_currentProcess = new KProcess;
*kp << m_unarchiver_program << "-v" << m_filename;
connect( kp, SIGNAL( receivedStdout(KProcess*, char*, int) ),
SLOT( slotReceivedTOC(KProcess*, char*, int) ) );
connect( kp, SIGNAL( receivedStderr(KProcess*, char*, int) ),
SLOT( slotReceivedOutput(KProcess*, char*, int) ) );
connect( kp, SIGNAL( processExited(KProcess*) ),
SLOT( slotOpenExited(KProcess*) ) );
if ( !kp->start( KProcess::NotifyOnExit, KProcess::AllOutput ) )
{
KMessageBox::error( 0, i18n( "Could not start a subprocess." ) );
emit sigOpen( this, false, QString::null, 0 );
}
}
CPerfTest::CPerfTest()
{
FOnPerformTest = NULL;
FOnOverallProgress = NULL;
m_strFileName = PS::FILESTRINGUTILS::CreateNewFileAtRoot(".csv");
//PS::FILESTRINGUTILS::changeFileExt(PS::FILESTRINGUTILS::GetExePath(), std::string(".csv"));
setHeaders();
}
// ------------------------------------------------------------------
void
JcnModel::clearAndReset()
{
if (jcndbg)
std::cout << "JcnModel::clearAndReset" << std::endl;
clear();
_entryMap.clear();
setHeaders();
}
// ------------------------------------------------------------------
JcnModel::JcnModel(QTableView * tv, Jcn * j) :
QStandardItemModel(0, JcnDD_Last),
_tv(tv),
_jcn(j)
{
if (jcndbg)
std::cout << "JcnModel::JcnModel" << std::endl;
setHeaders();
}
SonicXNFile::SonicXNFile(string filename, XNFileMode file_mode_parameter) {
File file(filename, LIBGENS_FILE_READ_BINARY);
info=NULL;
offset_table=NULL;
footer=NULL;
end=NULL;
big_endian=false;
folder = filename;
size_t sz=folder.size();
int last_slash=0;
for (size_t i=0; i<sz; i++) {
if ((folder[i] == '\\') || (folder[i] == '/')) last_slash=i;
}
if (last_slash) folder.erase(last_slash+1, folder.size()-last_slash-1);
else folder="";
std::transform(filename.begin(), filename.end(), filename.begin(), ::tolower);
if ((filename.find(LIBGENS_XNO_EXTENSION) != string::npos) || (filename.find(LIBGENS_XNM_EXTENSION) != string::npos) || (file_mode_parameter == MODE_XNO)) {
file_mode = MODE_XNO;
}
else if (filename.find(LIBGENS_ZNO_EXTENSION) != string::npos || (filename.find(LIBGENS_ZNM_EXTENSION) != string::npos) || (file_mode_parameter == MODE_ZNO)) {
file_mode = MODE_ZNO;
}
else if (filename.find(LIBGENS_INO_EXTENSION) != string::npos || (filename.find(LIBGENS_INM_EXTENSION) != string::npos) || (file_mode_parameter == MODE_INO)) {
file_mode = MODE_INO;
}
else if ((filename.find(LIBGENS_GNO_EXTENSION) != string::npos) || (filename.find(LIBGENS_GNM_EXTENSION) != string::npos) || (filename.find(LIBGENS_GNA_EXTENSION) != string::npos) || (file_mode_parameter == MODE_GNO)) {
file_mode = MODE_GNO;
}
else if (filename.find(LIBGENS_ENO_EXTENSION) != string::npos || (file_mode_parameter == MODE_ENO)) {
file_mode = MODE_ENO;
}
else if (file_mode_parameter == MODE_YNO) {
file_mode = MODE_YNO;
}
setHeaders();
if (file.valid()) {
while (!end) {
readSection(&file);
}
file.close();
}
SonicXNObject *object=getObject();
if (object) {
string name="Object";
if (footer) name=footer->name;
object->setNames(name);
}
}
void
TarArch::open()
{
if ( compressed )
QFile::remove(tmpfile); // just to make sure
setHeaders();
clearShellOutput();
// might as well plunk the output of tar -tvf in the shell output window...
//
// Now it's essential - used later to decide whether pathnames in the
// tar archive are plain or start with "./"
KProcess *kp = m_currentProcess = new KProcess;
*kp << m_archiver_program;
if ( compressed )
{
*kp << "--use-compress-program=" + getUnCompressor();
}
*kp << "-tvf" << m_filename;
m_buffer = "";
m_header_removed = false;
m_finished = false;
connect(kp, SIGNAL(processExited(KProcess *)),
this, SLOT(slotListingDone(KProcess *)));
connect(kp, SIGNAL(receivedStdout(KProcess*, char*, int)),
this, SLOT(slotReceivedOutput( KProcess *, char *, int )));
connect( kp, SIGNAL(receivedStderr(KProcess*, char*, int)),
this, SLOT(slotReceivedOutput(KProcess*, char*, int)));
if (kp->start(KProcess::NotifyOnExit, KProcess::AllOutput) == false)
{
KMessageBox::error( 0, i18n("Could not start a subprocess.") );
}
// We list afterwards because we want the signals at the end
// This unconfuses Extract Here somewhat
if ( m_fileMimeType == "application/x-tgz"
|| m_fileMimeType == "application/x-tbz" || !compressed )
{
openFirstCreateTempDone();
}
else
{
connect( this, SIGNAL( createTempDone() ), this, SLOT( openFirstCreateTempDone() ) );
createTmp();
}
}
void SampleModel::resetModel(QVector<Sample *> sample_mass)
{
beginResetModel();
setHeaders();
setWaterTypes();
setLocation();
setParams();
setSamples(sample_mass);
endResetModel();
}
virtual void onFinished(Status status, int responseCode, const std::string &body) override
{
std::cerr << errorMessage() << std::endl;
std::cerr << responseCode << std::endl;
std::cerr << body;
if (e++ == 0) {
std::map<std::string, std::string> headers;
headers["X-DERP"]= "funnies";
setHeaders(headers);
get("http://localhost:3000/");
} else {
ev()->exit(9);
}
}
bool Curl::doGet(const string& url) {
CURLcode r;
struct curl_slist* curl_header = NULL;
// make sure userpass/callback is set.
reset();
// use GET
r = curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
CHECK_CURL_ERROR(r);
// set URL
r = curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
CHECK_CURL_ERROR(r);
// no CA verification
r = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
CHECK_CURL_ERROR(r);
// set header
if(headers.size()) {
setHeaders(&curl_header);
if(curl_header) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_header);
}
}
// perform request.
bool result = true;
r = curl_easy_perform(curl);
if(r != CURLE_OK) {
result = false;
}
// clear header.
if(headers.size()) {
curl_slist_free_all(curl_header);
headers.clear();
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL); // opts are sticky
}
return result;
}
void SonicXNFile::setFileMode(XNFileMode target_file_mode) {
SonicXNObject *object=getObject();
SonicXNTexture *texture=getTexture();
SonicXNEffect *effect=getEffect();
SonicXNBones *bones=getBones();
SonicXNMotion *motion=getMotion();
file_mode = target_file_mode;
setHeaders();
if (info) {
info->setHeader(header_info);
info->setFileMode(file_mode);
}
if (object) {
object->setFileMode(file_mode);
object->setHeader(header_object);
}
if (texture) {
texture->setFileMode(file_mode);
texture->setHeader(header_texture);
}
if (effect) {
effect->setFileMode(file_mode);
effect->setHeader(header_effect);
}
if (bones) {
bones->setFileMode(file_mode);
bones->setHeader(header_bones);
}
if (motion) {
motion->setFileMode(file_mode);
motion->setHeader(header_motion);
}
if (offset_table) offset_table->setFileMode(file_mode);
if (footer) footer->setFileMode(file_mode);
if (end) end->setFileMode(file_mode);
}
PatientDataUpload::PatientDataUpload(QWidget *parent) :
QDialog(parent),
ui(new Ui::PatientDataUpload)
{
ui->setupUi(this);
ui->progressBar->setVisible(false);
ui->txtStatus->setText("");
this->fileList = new QStandardItemModel;
this->m_patient_id = 1;
setHeaders();
// For test
// QList<QStandardItem *> preparedRow =prepareRow("first", "second", "third");
// this->fileList->appendRow(preparedRow);
// QList<QStandardItem *> secondRow =prepareRow("111", "222", "333");
// this->fileList->appendRow(secondRow);
// End of Test
ui->treeFileList->setModel(this->fileList);
ui->treeFileList->expandAll();
}
jobject wyHttpRequest_android::createHttpRequest(JNIEnv* env) {
// check method, create java side request object
jobject request = NULL;
switch(m_method) {
case wyHttpRequest::GET:
case wyHttpRequest::DELETE:
{
const char* fullUrl = buildQueryString();
jstring jFullUrl = env->NewStringUTF(fullUrl);
request = env->CallStaticObjectMethod(gClass_Network, g_mid_Network_createHttpRequest, jFullUrl, (jint)m_method);
env->DeleteLocalRef(jFullUrl);
wyFree((void*)fullUrl);
break;
}
default:
{
// create request for post or put
jstring jUrl = env->NewStringUTF(m_url);
request = env->CallStaticObjectMethod(gClass_Network, g_mid_Network_createHttpRequest, jUrl, (jint)m_method);
env->DeleteLocalRef(jUrl);
// build post body
if(hasBlobParam())
buildMultipart(env, request);
else
buildKeyValuePost(env, request);
break;
}
}
// install headers
setHeaders(env, request);
// return
return request;
}
void StoreDocumentView::initGoodsTable() {
goodsTable = new QTableWidget();
goodsTable->setColumnCount(6);
goodsTable->setColumnWidth(0,300);
goodsTable->setColumnWidth(1,230);
goodsTable->setColumnWidth(2,120);
goodsTable->setColumnWidth(3,120);
goodsTable->setColumnWidth(4,110);
goodsTable->setColumnWidth(5,110);
goodsTable->setSelectionBehavior(QAbstractItemView::SelectRows);
setHeaders(0,new QTableWidgetItem("Nazwa"));
setHeaders(1,new QTableWidgetItem("Symbol"));
setHeaders(2,new QTableWidgetItem("Cena Netto"));
setHeaders(3,new QTableWidgetItem("Cena Brutto"));
setHeaders(4,new QTableWidgetItem("Ilość"));
setHeaders(5,new QTableWidgetItem("Wartość brutto"));
}
void SampleModel::resetModel()
{
beginResetModel();
setHeaders();
endResetModel();
}
bool Curl::doPost(const string& url, const rcp::Collection& params, bool multiPart) {
CURLcode r;
struct curl_slist* curl_header = NULL;
struct curl_httppost* post_curr = NULL;
struct curl_httppost* post_last = NULL;
string use_url = url; // @todo make url not const!s
// Make sure userpass/callback is set.
reset();
// Remove the Expect: from header, can give problems... (when you get a 417 error)
static const char buf[] = "Expect:";
curl_header = curl_slist_append(curl_header,buf);
// Add fields to post.
// ------------------------------------------------------
if(!multiPart) {
const list<rcp::Parameter*>& pars = params.getParameters();
string data_str = createQueryString(pars);
r = curl_easy_setopt(curl, CURLOPT_HTTPPOST, 1);
CHECK_CURL_ERROR(r);
r = curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, data_str.c_str());
CHECK_CURL_ERROR(r);
}
else {
// handling a multi part post.
const list<rcp::Parameter*>& post_params = params.getParameters();
list<rcp::Parameter*>::const_iterator it = post_params.begin();
while(it != post_params.end()) {
switch((*it)->type) {
case rcp::Parameter::PARAM_STRING: {
curl_formadd(
&post_curr
,&post_last
,CURLFORM_COPYNAME
,(*it)->getName().c_str()
,CURLFORM_COPYCONTENTS
,(*it)->getStringValue().c_str()
,CURLFORM_END
);
break;
}
case rcp::Parameter::PARAM_FILE: {
curl_formadd(
&post_curr
,&post_last
,CURLFORM_COPYNAME
,(*it)->getName().c_str()
,CURLFORM_FILE
,(*it)->getStringValue().c_str()
,CURLFORM_END
);
break;
}
default: {
printf("error type not handled: %d\n", (*it)->type);
break;
}
}
++it;
}
r = curl_easy_setopt(curl, CURLOPT_HTTPPOST, post_curr); // only for multi-part
CHECK_CURL_ERROR(r);
}
// no CA verification
r = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
CHECK_CURL_ERROR(r);
// set URL
r = curl_easy_setopt(curl, CURLOPT_URL, use_url.c_str());
CHECK_CURL_ERROR(r);
// set header
if(headers.size()) {
setHeaders(&curl_header);
}
if(curl_header) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_header);
}
// perform request.
bool result = true;
r = curl_easy_perform(curl);
if(r != CURLE_OK) {
result = false;
}
curl_formfree(post_curr);
// clear header.
curl_slist_free_all(curl_header);
headers.clear();
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL); // opts are sticky
return result;
}
/**
* Draws speed diagram to the UI
*
* @param QPaintEvent
*/
void ResultDialog::paintEvent(QPaintEvent *)
{
setHeaders();
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(QPen((Qt::gray),2));
QFont font;
QFont fontForResult;
font.setPixelSize(12);
painter.setFont(font);
painter.setBrush(QBrush((Qt::yellow), Qt::SolidPattern));
fontForResult.setPixelSize(50);
painter.setFont(fontForResult);
painter.drawText(diagramStemStart.x() + 50, diagramStemStart.y() - 150, resultString);
painter.setFont(font);
painter.setPen(QPen((Qt::darkCyan),2));
painter.drawLine(diagramStemStart, diagramStemEnd);
painter.drawLine(diagramHorizontalStart, diagramHorizontalEnd);
painter.drawText(diagramStemStart.x() - 50, diagramStemEnd.y() + 100, "S");
painter.drawText(diagramStemStart.x() - 50, diagramStemEnd.y() + 115, "P");
painter.drawText(diagramStemStart.x() - 50, diagramStemEnd.y() + 130, "E");
painter.drawText(diagramStemStart.x() - 50, diagramStemEnd.y() + 145, "E");
painter.drawText(diagramStemStart.x() - 50, diagramStemEnd.y() + 160, "D");
painter.drawText(diagramStemStart.x() - 65, diagramStemEnd.y() + 180, "(km/h)");
painter.drawText(diagramStemStart.x() + 140, diagramStemStart.y() + 40, "T");
painter.drawText(diagramStemStart.x() + 150, diagramStemStart.y() + 40, "I");
painter.drawText(diagramStemStart.x() + 155, diagramStemStart.y() + 40, "M");
painter.drawText(diagramStemStart.x() + 165, diagramStemStart.y() + 40, "E");
painter.drawText(diagramStemStart.x() + 180, diagramStemStart.y() + 40, "(s)");
int currentX = 0;
int currentY = diagramStemStart.y();
painter.setPen(QPen((Qt::darkCyan),1));
int i = 0;
// Draws diagram's X-axel
while (currentX <= DIAGRAM_WIDTH)
{
painter.drawLine(currentX + diagramStemStart.x(), currentY, currentX + diagramStemStart.x(), currentY - 300);
painter.drawText(currentX + diagramStemStart.x() - 3, currentY + 20, timeList[i]);
currentX += this->diagramGapHorizontal;
i++;
}
currentX = diagramStemStart.x();
currentY = 0;
i = 0;
// Draws diagram's Y-axel
while (currentY >= -(DIAGRAM_HEIGHT))
{
painter.drawLine(currentX, diagramStemStart.y() + currentY, currentX+400, diagramStemStart.y() + currentY);
painter.drawText(currentX - 25, diagramStemStart.y() + currentY + 3, speedList[i]);
currentY -= this->diagramGapStem;
i++;
}
painter.setPen(QPen((Qt::red),2));
int pointsToShow = 0;
bool pointsUnderDiagramWidth = true;
for (i = 0; i < 11 ; i++)
{
if (points[i].x() > diagramHorizontalEnd.x())
{
pointsToShow = i;
pointsUnderDiagramWidth = false;
i = 10;
}
}
// Draws result line to the diagram
if (pointsUnderDiagramWidth)
{
painter.drawPolyline(points, this->getTargetChoice() + 1);
}
else
{
painter.drawPolyline(points, pointsToShow);
}
}
void
GTransport::request(const HTTP_REQUEST_TYPE type)
{
FUNCTION_CALL_TRACE;
LOG_DEBUG ("Request type:" << type);
if (iNetworkRequest)
{
delete iNetworkRequest;
iNetworkRequest = NULL;
}
if (iNetworkRequest == NULL)
{
if (iNetworkReply)
{
//iNetworkReply->deleteLater ();
iNetworkReply = NULL;
}
}
iNetworkReplyBody = "";
iNetworkRequest = new QNetworkRequest ();
iNetworkRequest->setUrl (iUrl);
setHeaders ();
mRequestType = type;
LOG_DEBUG("++URL:" << iNetworkRequest->url ().toString ());
switch (type)
{
case GET: {
iNetworkReply = iNetworkMgr.get(*iNetworkRequest);
LOG_DEBUG ("--- FINISHED GET REQUEST ---");
}
break;
case POST: {
iNetworkRequest->setHeader (QNetworkRequest::ContentLengthHeader, iPostData.size ());
iNetworkReply = iNetworkMgr.post(*iNetworkRequest, iPostData);
LOG_DEBUG ("--- FINISHED POST REQUEST ---");
}
break;
case PUT:
iNetworkRequest->setHeader (QNetworkRequest::ContentLengthHeader, iPostData.size ());
iNetworkReply = iNetworkMgr.put(*iNetworkRequest, iPostData);
LOG_DEBUG ("--- FINISHED PUT REQUEST ---");
break;
case DELETE:
iNetworkReply = iNetworkMgr.deleteResource(*iNetworkRequest);
break;
case HEAD:
// Nothing
break;
default:
// FIXME: signal the error
break;
}
QList<QByteArray> headerList = iNetworkRequest->rawHeaderList ();
for (int i=0; i<headerList.size (); i++)
{
LOG_DEBUG ("Header " << i << ":" << headerList.at (i)
<< ":" << iNetworkRequest->rawHeader (headerList.at (i)));
}
QObject::connect(iNetworkReply, SIGNAL(readyRead ()), this,
SLOT(readyRead()));
}
PUBLIC void httpWriteHeaders(HttpQueue *q, HttpPacket *packet)
{
Http *http;
HttpConn *conn;
HttpTx *tx;
HttpUri *parsedUri;
MprKey *kp;
MprBuf *buf;
int level;
assert(packet->flags == HTTP_PACKET_HEADER);
conn = q->conn;
http = conn->http;
tx = conn->tx;
buf = packet->content;
if (tx->flags & HTTP_TX_HEADERS_CREATED) {
return;
}
tx->flags |= HTTP_TX_HEADERS_CREATED;
tx->responded = 1;
if (conn->headersCallback) {
/* Must be before headers below */
(conn->headersCallback)(conn->headersCallbackArg);
}
if (tx->flags & HTTP_TX_USE_OWN_HEADERS && !conn->error) {
conn->keepAliveCount = 0;
return;
}
setHeaders(conn, packet);
if (conn->endpoint) {
mprPutStringToBuf(buf, conn->protocol);
mprPutCharToBuf(buf, ' ');
mprPutIntToBuf(buf, tx->status);
mprPutCharToBuf(buf, ' ');
mprPutStringToBuf(buf, httpLookupStatus(http, tx->status));
} else {
mprPutStringToBuf(buf, tx->method);
mprPutCharToBuf(buf, ' ');
parsedUri = tx->parsedUri;
if (http->proxyHost && *http->proxyHost) {
if (parsedUri->query && *parsedUri->query) {
mprPutToBuf(buf, "http://%s:%d%s?%s %s", http->proxyHost, http->proxyPort,
parsedUri->path, parsedUri->query, conn->protocol);
} else {
mprPutToBuf(buf, "http://%s:%d%s %s", http->proxyHost, http->proxyPort, parsedUri->path,
conn->protocol);
}
} else {
if (parsedUri->query && *parsedUri->query) {
mprPutToBuf(buf, "%s?%s %s", parsedUri->path, parsedUri->query, conn->protocol);
} else {
mprPutStringToBuf(buf, parsedUri->path);
mprPutCharToBuf(buf, ' ');
mprPutStringToBuf(buf, conn->protocol);
}
}
}
if ((level = httpShouldTrace(conn, HTTP_TRACE_TX, HTTP_TRACE_FIRST, tx->ext)) >= mprGetLogLevel(tx)) {
mprAddNullToBuf(buf);
mprLog(level, " %s", mprGetBufStart(buf));
}
mprPutStringToBuf(buf, "\r\n");
/*
Output headers
*/
kp = mprGetFirstKey(conn->tx->headers);
while (kp) {
mprPutStringToBuf(packet->content, kp->key);
mprPutStringToBuf(packet->content, ": ");
if (kp->data) {
mprPutStringToBuf(packet->content, kp->data);
}
mprPutStringToBuf(packet->content, "\r\n");
kp = mprGetNextKey(conn->tx->headers, kp);
}
/*
By omitting the "\r\n" delimiter after the headers, chunks can emit "\r\nSize\r\n" as a single chunk delimiter
*/
if (tx->length >= 0 || tx->chunkSize <= 0) {
mprPutStringToBuf(buf, "\r\n");
}
if (tx->altBody) {
/* Error responses are emitted here */
mprPutStringToBuf(buf, tx->altBody);
httpDiscardQueueData(tx->queue[HTTP_QUEUE_TX]->nextQ, 0);
}
tx->headerSize = mprGetBufLength(buf);
tx->flags |= HTTP_TX_HEADERS_CREATED;
q->count += httpGetPacketLength(packet);
}
