void nc_scr_frame_draw(struct nc_scr *scr)
{
int ltitle_len, rtitle_len;
DBGS("ltitle '%s'\n", scr->frame.ltitle);
DBGS("rtitle '%s'\n", scr->frame.rtitle);
DBGS("help '%s'\n", scr->frame.help);
DBGS("status '%s'\n", scr->frame.status);
ltitle_len = strlen(scr->frame.ltitle);
rtitle_len = scr->frame.rtitle ? strlen(scr->frame.rtitle) : 0;
/* if both ltitle and rtitle don't fit, trim rtitle */
if (ltitle_len + rtitle_len + nc_scr_pos_lrtitle_space > COLS - 2)
rtitle_len = COLS - 2 - ltitle_len - nc_scr_pos_lrtitle_space;
mvwaddstr(scr->main_ncw, nc_scr_pos_title, 1, scr->frame.ltitle);
mvwaddnstr(scr->main_ncw, nc_scr_pos_title, COLS - rtitle_len - 1,
scr->frame.rtitle, rtitle_len);
mvwhline(scr->main_ncw, nc_scr_pos_title_sep, 1, ACS_HLINE, COLS - 2);
mvwhline(scr->main_ncw, LINES - nc_scr_pos_help_sep, 1, ACS_HLINE,
COLS - 2);
mvwaddstr(scr->main_ncw, LINES - nc_scr_pos_help, 1, scr->frame.help);
nc_scr_status_draw(scr);
}
int DataBase::write(QString filePath) {
DBGS(PRINT_START("filePath: %s", qPrintable(filePath)));
int rv = ERROR_UNKNOWN_ERROR;
updateDOMKsilit();
updateDOMJotterHeader();
updateDOMJotterBody(rootItem);
QString xmlString = domDoc.toString();
if (!xmlString.isEmpty()) {
QFile fileOut(filePath);
if (fileOut.open(QIODevice::WriteOnly)) {
QTextStream outStream(&fileOut);
outStream << xmlString;
fileOut.close();
rv = ALL_OK;
}
else {
DBGE(PRINT_ERROR("Error opening file: %s", qPrintable(filePath)));
rv = ERROR_OPENING_FILE;
}
}
else {
DBGE(PRINT_ERROR("xmlString is empty!"));
}
DBGR(PRINT_RETURN("rv: %i", rv));
return rv;
}
QDomNode DataBase::getNextNode(QDomNode ¤tNode, QDomNode &lastNode) {
DBGS(PRINT_START("currentNode: 0x%08x, lastNode: 0x%08x", ¤tNode, &lastNode));
QDomNode nextNode;
if (currentNode.hasChildNodes()) {
nextNode = currentNode.firstChild();
}
else {
QDomNode previousNode = currentNode;
nextNode = currentNode.nextSibling();
while (nextNode.isNull()) {
QDomNode parentNode = previousNode.parentNode();
if (parentNode == lastNode) {
break;
}
else {
previousNode = parentNode;
nextNode = parentNode.nextSibling();
}
}
}
DBGR(PRINT_RETURN("nextNode: 0x%08x", &nextNode));
return nextNode;
}
void Jotter::reset() {
DBGS(PRINT_START(""));
map.clear();
setJotCount(0);
DBGR(PRINT_RETURN(""));
}
void DataBase::updateDOMKsilit() {
DBGS(PRINT_START(""));
domDoc.clear();
QString ksilitName = KSILIT_DOM_TAG;
QDomElement ksilitElement = domDoc.createElement(ksilitName);
domDoc.appendChild(ksilitElement);
DBGR(PRINT_RETURN(""));
}
CK_RV
p11c_session_create(CK_SLOT_ID slot, P11cSession** ret)
{
P11cSession* sess;
const char *store;
DWORD err;
sess = calloc(1, sizeof(P11cSession));
if(!sess)
return CKR_HOST_MEMORY;
sess->object_data = p11c_hash_new(NULL, NULL);
if(!sess->object_data) {
free(sess);
return CKR_HOST_MEMORY;
}
sess->mutex = CreateMutex(NULL, FALSE, NULL);
if(!sess->mutex) {
p11c_hash_free(sess->object_data, NULL);
free(sess);
return CKR_HOST_MEMORY;
}
store = p11c_token_get_store_name(slot);
if(store)
{
sess->store = CertOpenSystemStore((HCRYPTPROV)NULL, store);
if(sess->store == NULL)
{
err = GetLastError();
/* Store not found, we don't care */
if(err != ERROR_FILE_NOT_FOUND)
{
p11c_hash_free(sess->object_data, NULL);
CloseHandle(sess->mutex);
free(sess);
return p11c_winerr_to_ckr(err);
}
}
}
sess->slot = slot;
DBGS(sess, "created");
*ret = sess;
return CKR_OK;
}
//Returns 0 if jot not found
Jot *Jotter::getJot(int id) {
DBGS(PRINT_START("id: %i", id));
Jot *jot = 0;
if (map.contains(id)) {
jot = map.value(id);
}
else {
DBGE(PRINT_ERROR("Jot with id: %i not found!", id));
}
DBGR(PRINT_RETURN("jot: 0x%08x", jot));
return jot;
}
QString Jotter::getText(int id) {
DBGS(PRINT_START("id: %i", id));
QString text;
Jot *jot = getJot(id);
if (jot) {
text = jot->getText();
}
else {
DBGE(PRINT_ERROR("Jot with id: %i not found!", id));
}
DBGR(PRINT_RETURN("text: %s", qPrintable(text)));
return text;
}
void DataBase::updateDOMJotterHeader() {
DBGS(PRINT_START(""));
QString ksilitName = KSILIT_DOM_TAG;
QDomNodeList ksilitNodeList = domDoc.elementsByTagName(ksilitName);
QDomNode ksilitNode = ksilitNodeList.at(0);
QDomElement ksilitElement = ksilitNode.toElement();
QString headerName = KSILIT_JOTTER_DOM_HEADER_TAG;
QDomElement headerElement = domDoc.createElement(headerName);
QString attributeJotCounter = KSILIT_JOTTER_DOM_JOT_COUNTER;
int jotCounter = jotter->getJotCount();
headerElement.setAttribute(attributeJotCounter, jotCounter);
ksilitElement.appendChild(headerElement);
DBGR(PRINT_RETURN(""));
}
QString Jotter::getName(int id) {
DBGS(PRINT_START("id: %i", id));
QString name;
Jot *jot = getJot(id);
if (jot) {
name = jot->getName();
}
else {
DBGE(PRINT_ERROR("Jot with id: %i not found!", id));
}
DBGR(PRINT_RETURN("Found name: %s", qPrintable(name)));
return name;
}
int Jotter::setName(int id, QString jotName) {
DBGS(PRINT_START("id: %i, jotName: %s", id, qPrintable(jotName)));
int rv = ERROR_UNKNOWN_ERROR;
Jot *jot = getJot(id);
if (jot) {
jot->setName(jotName);
rv = ALL_OK;
}
else {
DBGE(PRINT_ERROR("Jot with id: %i not found!", id));
}
DBGR(PRINT_RETURN("rv: %i", rv));
return rv;
}
//Return id of a new jot
//if useId == -1, next id from jotCounter will be used
//else id = useId
int Jotter::createJot(int useId) {
DBGS(PRINT_START(""));
int id = 0;
Jot *jot = new Jot();
if (useId == -1) {
incJotCounter();
id = getJotCount();
}
else {
id = useId;
}
map.insert(id, jot);
DBGR(PRINT_RETURN("id: %i", id));
return id;
}
//------------------------------------------------------------------------
QPixmap * Terrain::createPixmap (time_t date, int width, int height)
{
Projection *scaledproj = proj->clone();
MapDrawer *scaleddrawer = new MapDrawer (*drawer);
if (scaledproj && scaleddrawer)
{
double x0,y0, x1,y1;
scaledproj->getVisibleArea (&x0,&y0, &x1,&y1);
scaledproj->setScreenSize (width, height);
scaledproj->setVisibleArea (x0,y0, x1,y1);
switch (currentFileType) {
case DATATYPE_GRIB :
case DATATYPE_MBLUE :
if (griddedPlot && griddedPlot->isReaderOk() )
{
return scaleddrawer->createPixmap_GriddedData (
date,
false,
griddedPlot,
scaledproj,
getListPOIs() );
}
break;
case DATATYPE_IAC :
if (iacPlot && iacPlot->isReaderOk() )
{
DBGS("TODO: save image IAC")
}
break;
default : // draw only map
return scaleddrawer->createPixmap_GriddedData (
date,
false,
NULL,
scaledproj,
getListPOIs() );
return NULL;
}
delete scaledproj;
delete scaleddrawer;
}
int DataBase::readJotterHeader() {
DBGS(PRINT_START(""));
int rv = ERROR_UNKNOWN_ERROR;
QString headerName = KSILIT_JOTTER_DOM_HEADER_TAG;
QDomNodeList headerList = domDoc.elementsByTagName(headerName);
QDomNode headerNode = headerList.at(0);
QDomElement headerElement = headerNode.toElement();
QString attributeJotCounter = headerElement.attribute(KSILIT_JOTTER_DOM_JOT_COUNTER);
int jotCounter = attributeJotCounter.toInt();
rv = jotter->setJotCount(jotCounter);
if (rv != ALL_OK) {
DBGE(PRINT_ERROR("Error setting jotCounter!"));
}
DBGR(PRINT_RETURN("rv: %i", rv));
return rv;
}
int main(int argc, char *argv[]) {
DBGS(PRINT_START());
int rv = 0;
rv = unitTestProcess();
if (rv == 0) {
QApplication a(argc, argv);
MainWindow w;
w.show();
a.exec();
}
else {
DBGE(PRINT_ERROR("Unit tests fail!"));
}
DBGR(PRINT_RETURN("rv: %i", rv));
return rv;
}
//---------------------------------------------------
void MbzFile::debugmbz () const
{
DBGS ("--------------------");
if (ok) {
for (unsigned int i=0; i<vcodes.size(); i++) {
DataCode dtc (vcodes[i]);
DBG ("dtc %2d: %3d %3d %5d", i,dtc.dataType,dtc.levelType,dtc.levelValue);
}
DBG ("%d %d %d %d", year,month,day,href);
DBG ("Data:%d Lines:%d", nbData, nbLines);
DBG ("X: %f %f Y: %f %f", xmin,xmax, ymin,ymax);
std::set<int> alldates;
for (uint32_t i=0; i<vlines.size(); i++)
{
alldates.insert (vlines[i]->hour);
}
int nbdates = alldates.size();
alldates.clear ();
if (nbdates>0 && xmax!=xmin && ymax!=ymin) {
double dens = nbLines /nbdates / (fabs(xmax-xmin)*fabs(ymax-ymin));
double ec = 0;
if (dens > 0) {
ec = 1/sqrt(dens);
}
DBG ("nb dates: %d density: %.1f %.5f", nbdates, dens, ec);
DBG ("vlines.size()=%d %d/hour", (int)vlines.size(), (int)(vlines.size()/nbdates));
}
if (vlines.size()>0) vlines[0]->print();
if (vlines.size()>1) vlines[1]->print();
if (vlines.size()>0) vlines[vlines.size()-1]->print();
}
else {
DBG ("Error in file");
}
}
Jot::Jot()
{
DBGS(PRINT_START(""));
DBGR(PRINT_RETURN(""));
}
CK_RV
p11c_session_register(P11cSession* sess)
{
P11cSession* blank = NULL;
CK_SESSION_HANDLE id = 0;
CK_RV ret = CKR_OK;
size_t i;
ASSERT(sess);
ASSERT(sess->id == 0 && sess->refs == 0);
DBGS(sess, "registering new session");
p11c_lock_global();
/* Find a nice session identifier */
while(id == 0) {
/* Allocate sessions properly */
if(!all_sessions)
{
all_sessions = p11c_array_new(0, 1, sizeof(P11cSession*));
if(!all_sessions)
{
ret = CKR_HOST_MEMORY;
break;
}
/* A blank entry for '0' */
p11c_array_append(all_sessions, blank);
DBG(("allocated new session list"));
}
/*
* PKCS#11 GRAY AREA: We're assuming we can reuse session
* handles. PKCS#11 spec says they're like file handles,
* and file handles get reused :)
*/
/* Note we never put anything in array position '0' */
for(i = 1; i < all_sessions->len; ++i)
{
/* Any empty position will do */
if(!p11c_array_index(all_sessions, P11cSession*, i))
{
id = i;
break;
}
}
/* Couldn't find a handle, append a handle */
if(id == 0)
{
id = all_sessions->len;
p11c_array_append(all_sessions, blank);
}
}
if(ret == CKR_OK)
{
ASSERT(id > 0 && id < all_sessions->len);
ASSERT(!p11c_array_index(all_sessions, P11cSession*, id));
/* And assign it to the session handle */
p11c_array_index(all_sessions, P11cSession*, i) = sess;
sess->id = id;
/* The session list reference */
ASSERT(sess->refs == 0);
sess->refs++;
DBGS(sess, "registered sesson id");
}
int DataBase::read(QString filePath) {
DBGS(PRINT_START("filePath: %s", qPrintable(filePath)));
int rv = ERROR_UNKNOWN_ERROR;
QFile fileIn(filePath);
if (fileIn.open(QIODevice::ReadOnly)) {
if (domDoc.setContent(&fileIn)) {
rv = readJotterHeader();
if (rv == ALL_OK) {
QString bodyName = KSILIT_JOTTER_DOM_BODY_TAG;
QDomNodeList bodyList = domDoc.elementsByTagName(bodyName);
QDomNode bodyNode = bodyList.at(0);
QDomElement bodyElement = bodyNode.toElement();
if (!bodyElement.isNull()) {
int rootId = 0;
QString rootNodeName = KSILIT_JOTTER_DOM_ELEMENT_TAG;
rootNodeName += QString::number(rootId);
QDomNodeList rootNodeList = domDoc.elementsByTagName(rootNodeName);
QDomNode rootNode = rootNodeList.at(0);
QDomElement rootElement = rootNode.toElement();
QDomNode childNode = rootElement.firstChild();
while (!childNode.isNull()) {
QDomElement childElement = childNode.toElement();
QString childTag = childElement.tagName();
DBG3(PRINT_DBG("childTag: %s", qPrintable(childTag)));
QString attributeChildId = childElement.attribute(KSILIT_JOTTER_DOM_ELEMENT_ATTRIBUTE_ID);
DBG3(PRINT_DBG("attributeChildId: %s", qPrintable(attributeChildId)));
QString attributeChildName = childElement.attribute(KSILIT_JOTTER_DOM_ELEMENT_ATTRIBUTE_NAME);
DBG3(PRINT_DBG("attributeChildName: %s", qPrintable(attributeChildName)));
QString attributeChildText = childElement.attribute(KSILIT_JOTTER_DOM_ELEMENT_ATTRIBUTE_TEXT);
DBG3(PRINT_DBG("attributeChildText: %s", qPrintable(attributeChildText)));
QDomNode parentNode = childElement.parentNode();
if (!parentNode.isNull()) {
QDomElement parentElement = parentNode.toElement();
if (!parentElement.isNull()) {
int parentId = 0;
QString attributeParentId = parentElement.attribute(KSILIT_JOTTER_DOM_ELEMENT_ATTRIBUTE_ID);
if (!attributeParentId.isEmpty()) {
parentId = attributeParentId.toInt();
}
DBG3(PRINT_DBG("parentId: %i", parentId));
QStandardItem *parentItem = rootItem;
if (parentId) {
parentItem = getItemById(rootItem, parentId);
}
if (parentItem){
QStandardItem *childItem = new QStandardItem();
parentItem->appendRow(childItem);
QVariant childData = attributeChildId;
childItem->setData(childData);
childItem->setText(attributeChildName);
int childId = attributeChildId.toInt();
jotter->createJot(childId);
jotter->setName(childId, attributeChildName);
jotter->setText(childId, attributeChildText);
}
else {
DBGE(PRINT_ERROR("parentItem not found!"));
}
}
else {
DBGE(PRINT_ERROR("Error converting parent node to element!"));
}
}
else {
DBGE(PRINT_ERROR("parentNode is null!"));
}
childNode = getNextNode(childNode, rootNode);
if (childNode.isNull()) {
rv = ALL_OK;
}
}
}
else {
DBGE(PRINT_ERROR("rootElement is null!"));
}
}
else {
DBGE(PRINT_ERROR("Error reading jotter header!"));
}
}
else {
DBGE(PRINT_ERROR("Error setting DOM document content!"));
}
}
else {
DBGE(PRINT_ERROR("Error opening file: %s", qPrintable(filePath)));
rv = ERROR_OPENING_FILE;
}
fileIn.close();
DBGR(PRINT_RETURN("rv: %i", rv));
return rv;
}
