esp_err_t Storage::writeItem(uint8_t nsIndex, ItemType datatype, const char* key, const void* data, size_t dataSize)
{
if (mState != StorageState::ACTIVE) {
return ESP_ERR_NVS_NOT_INITIALIZED;
}
Page* findPage = nullptr;
Item item;
auto err = findItem(nsIndex, datatype, key, findPage, item);
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) {
return err;
}
Page& page = getCurrentPage();
err = page.writeItem(nsIndex, datatype, key, data, dataSize);
if (err == ESP_ERR_NVS_PAGE_FULL) {
if (page.state() != Page::PageState::FULL) {
err = page.markFull();
if (err != ESP_OK) {
return err;
}
}
err = mPageManager.requestNewPage();
if (err != ESP_OK) {
return err;
}
err = getCurrentPage().writeItem(nsIndex, datatype, key, data, dataSize);
if (err == ESP_ERR_NVS_PAGE_FULL) {
return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
}
if (err != ESP_OK) {
return err;
}
} else if (err != ESP_OK) {
return err;
}
if (findPage) {
if (findPage->state() == Page::PageState::UNINITIALIZED ||
findPage->state() == Page::PageState::INVALID) {
ESP_ERROR_CHECK( findItem(nsIndex, datatype, key, findPage, item) );
}
err = findPage->eraseItem(nsIndex, datatype, key);
if (err == ESP_ERR_FLASH_OP_FAIL) {
return ESP_ERR_NVS_REMOVE_FAILED;
}
if (err != ESP_OK) {
return err;
}
}
#ifndef ESP_PLATFORM
debugCheck();
#endif
return ESP_OK;
}
//--------------------------------------------------------------
void Gui::keyPressed(int key) {
if(!pages.size()) return;
if(doDefaultKeys) {
if(key == ' ') {
toggleDraw();
} else if(key>='1' && key<='9') {
setPage((int)(key - '1')+1);
setDraw(true);
} else if(doDraw) {
switch(key) {
case '[': prevPage(); break;
case ']': nextPage(); break;
}
}
}
if(!doDraw) return;
ofKeyEventArgs e;
e.key = key;
if(!getActiveControls().empty()) {
getActiveControls()[0]->_keyPressed(e);
} else {
getCurrentPage().keyPressed(key);
Container::keyPressed(key);
}
}
void WXTableView::nextpageRelocateContainer(bool animated)
{
CCPoint oldPoint, min, max;
float newX, newY;
min = this->minContainerOffset();
max = this->maxContainerOffset();
oldPoint = m_desire_containerPos_nextPage;
newX = oldPoint.x;
newY = oldPoint.y;
if (_direction == ScrollView::Direction::BOTH || _direction == ScrollView::Direction::HORIZONTAL)
{
newX = MAX(newX, min.x);
newX = MIN(newX, max.x);
}
if (_direction == ScrollView::Direction::BOTH || _direction ==ScrollView::Direction::VERTICAL)
{
newY = MIN(newY, max.y);
newY = MAX(newY, min.y);
}
this->setContentOffset(ccp(newX, newY), animated);
int currentPage = getCurrentPage();
if (m_pTarget && m_pSelector)
{
(m_pTarget->*m_pSelector)(currentPage);
}
}
//--------------------------------------------------------------
void Gui::draw() {
if(!checkOkToRun()) return;
ofPushStyle();
ofEnableSmoothing();
ofDisableNormalizedTexCoords();
ofDisableLighting();
glDisable(GL_DEPTH_TEST);
Renderer::instance().clearControls();
// iterate all controls on page, set position and add to render queue
Page &page = getCurrentPage();
page.layout.x = getConfig()->layout.scrollbarWidth;
pLayoutManager->clearParentRect(*this);
page.arrangeControls(true);
_pGuiControls->arrangeControls(true);
pLayoutManager->update();
// sort and draw
Renderer::instance().draw();
ofPopStyle();
// draw debug boxes around containers
// ofPushStyle();
// ofSetRectMode(OF_RECTMODE_CORNER);
// ofNoFill();
// ofSetColor(0, 255 ,0);
// ofDrawRectangle(page.x, page.y, page.width, page.height);
// ofSetColor(0, 0, 255);
// ofDrawRectangle(x, y, width, height);
// ofPopStyle();
}
//--------------------------------------------------------------
void Gui::update() {
if(!checkOkToRun()) return;
// if(!isSetup) setup();
Container::update();
getCurrentPage()._update();
Container::update();
}
//--------------------------------------------------------------
void Gui::keyReleased(int key) {
if(!checkOkToRun()) return;
ofKeyEventArgs e;
e.key = key;
if(!getActiveControls().empty()) {
getActiveControls()[0]->_keyReleased(e);
} else {
getCurrentPage().keyReleased(key);
Container::keyReleased(key);
}
}
bool XournalView::actionDelete()
{
XOJ_CHECK_TYPE(XournalView);
size_t p = getCurrentPage();
if (p == size_t_npos || p >= viewPagesLen)
{
return false;
}
XojPageView* page = viewPages[p];
return page->actionDelete();
}
bool XournalView::actionDelete()
{
XOJ_CHECK_TYPE(XournalView);
int p = getCurrentPage();
if (p < 0 || p >= viewPagesLen)
{
return false;
}
PageView* page = viewPages[p];
return page->actionDelete();
}
bool XournalView::onKeyReleaseEvent(GdkEventKey* event)
{
XOJ_CHECK_TYPE(XournalView);
size_t p = getCurrentPage();
if (p != size_t_npos && p < this->viewPagesLen)
{
XojPageView* v = this->viewPages[p];
if (v->onKeyReleaseEvent(event))
{
return true;
}
}
return false;
}
//--------------------------------------------------------------
void Gui::mouseMoved(int x, int y) {
if(!checkOkToRun()) return;
ofMouseEventArgs e;
e.x = x;
e.y = y;
if(!getActiveControls().empty()) {
getActiveControls()[0]->_mouseMoved(e);
} else {
// for(int i=0; i<Renderer::instance().controls.size(); i++) {
// Control *control = Renderer::instance().controls[i];
// control->_mouseMoved(e);
// }
getCurrentPage().mouseMoved(x, y);
Container::mouseMoved(x, y);
}
}
void XournalView::pageRelativeXY(int offCol, int offRow)
{
XOJ_CHECK_TYPE(XournalView);
int currPage = getCurrentPage();
XojPageView* view = getViewFor(currPage );
int row = view->getMappedRow();
int col = view->getMappedCol();
Layout* layout = gtk_xournal_get_layout(this->widget);
int page = layout->getIndexAtGridMap(row +offRow ,col + offCol);
if( page >=0)
{
this-> scrollTo(page, 0);
}
}
void XournalView::getPasteTarget(double& x, double& y)
{
XOJ_CHECK_TYPE(XournalView);
size_t pageNo = getCurrentPage();
if (pageNo == size_t_npos)
{
return;
}
Rectangle* rect = getVisibleRect(pageNo);
if (rect)
{
x = rect->x + rect->width / 2;
y = rect->y + rect->height / 2;
delete rect;
}
}
void XournalView::zoomChanged()
{
XOJ_CHECK_TYPE(XournalView);
Layout* layout = gtk_xournal_get_layout(this->widget);
int currentPage = this->getCurrentPage();
XojPageView* view = getViewFor(currentPage);
ZoomControl* zoom = control->getZoomControl();
if (!view)
{
return;
}
// move this somewhere else maybe
layout->layoutPages();
if(zoom->isZoomPresentationMode() || zoom->isZoomFitMode())
{
scrollTo(currentPage);
}
else
{
std::tuple<double, double> pos = zoom->getScrollPositionAfterZoom();
if(std::get<0>(pos) != -1 && std::get<1>(pos) != -1)
{
layout->scrollAbs(std::get<0>(pos), std::get<1>(pos));
}
}
Document* doc = control->getDocument();
doc->lock();
Path file = doc->getEvMetadataFilename();
doc->unlock();
control->getMetadataManager()->storeMetadata(file.str(), getCurrentPage(), zoom->getZoomReal());
// Updates the Eraser's cursor icon in order to make it as big as the erasing area
control->getCursor()->updateCursor();
this->control->getScheduler()->blockRerenderZoom();
}
bool XournalView::onKeyPressEvent(GdkEventKey* event)
{
XOJ_CHECK_TYPE(XournalView);
size_t p = getCurrentPage();
if (p != size_t_npos && p < this->viewPagesLen)
{
XojPageView* v = this->viewPages[p];
if (v->onKeyPressEvent(event))
{
return true;
}
}
// Esc leaves fullscreen mode
if (event->keyval == GDK_KEY_Escape || event->keyval == GDK_KEY_F11)
{
if (control->isFullscreen())
{
control->setFullscreen(false);
return true;
}
}
// F5 starts presentation modus
if (event->keyval == GDK_KEY_F5)
{
if (!control->isFullscreen())
{
control->setViewPresentationMode(true);
control->setFullscreen(true);
return true;
}
}
guint state = event->state & gtk_accelerator_get_default_mod_mask();
Layout* layout = gtk_xournal_get_layout(this->widget);
if (state & GDK_SHIFT_MASK)
{
GtkAllocation alloc =
{ 0 };
gtk_widget_get_allocation(gtk_widget_get_parent(this->widget), &alloc);
int windowHeight = alloc.height - scrollKeySize;
if (event->keyval == GDK_KEY_Page_Down)
{
layout->scrollRelative(0, windowHeight);
return false;
}
if (event->keyval == GDK_KEY_Page_Up || event->keyval == GDK_KEY_space)
{
layout->scrollRelative(0, -windowHeight);
return true;
}
}
else
{
if (event->keyval == GDK_KEY_Page_Down || event->keyval == GDK_KEY_KP_Page_Down)
{
control->getScrollHandler()->goToNextPage();
return true;
}
if (event->keyval == GDK_KEY_Page_Up || event->keyval == GDK_KEY_KP_Page_Up)
{
control->getScrollHandler()->goToPreviousPage();
return true;
}
}
if (event->keyval == GDK_KEY_space) {
GtkAllocation alloc = { 0 };
gtk_widget_get_allocation(gtk_widget_get_parent(this->widget), &alloc);
int windowHeight = alloc.height - scrollKeySize;
layout->scrollRelative(0, windowHeight);
return true;
}
//Numeric keypad always navigates by page
if (event->keyval == GDK_KEY_KP_Up)
{
this->pageRelativeXY(0,-1);
return true;
}
if (event->keyval == GDK_KEY_KP_Down)
{
this->pageRelativeXY(0,1);
return true;
}
if (event->keyval == GDK_KEY_KP_Left)
{
this->pageRelativeXY(-1, 0);
return true;
}
if (event->keyval == GDK_KEY_KP_Right)
{
this->pageRelativeXY(1,0);
return true;
}
if (event->keyval == GDK_KEY_Up)
{
if (control->getSettings()->isPresentationMode())
{
control->getScrollHandler()->goToPreviousPage();
return true;
}
else
{
if (state & GDK_SHIFT_MASK)
{
this->pageRelativeXY(0,-1);
}
else
{
layout->scrollRelative(0, -scrollKeySize);
}
return true;
}
}
if (event->keyval == GDK_KEY_Down)
{
if (control->getSettings()->isPresentationMode())
{
control->getScrollHandler()->goToNextPage();
return true;
}
else
{
if (state & GDK_SHIFT_MASK)
{
this->pageRelativeXY(0,1);
}
else
{
layout->scrollRelative(0, scrollKeySize);
}
return true;
}
}
if (event->keyval == GDK_KEY_Left)
{
if (state & GDK_SHIFT_MASK)
{
this->pageRelativeXY(-1,0);
}
else
{
layout->scrollRelative(-scrollKeySize, 0);
}
return true;
}
if (event->keyval == GDK_KEY_Right)
{
if (state & GDK_SHIFT_MASK)
{
this->pageRelativeXY(1,0);
}
else
{
layout->scrollRelative(scrollKeySize, 0);
}
return true;
}
if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
{
control->getScrollHandler()->goToLastPage();
return true;
}
if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
{
control->getScrollHandler()->goToFirstPage();
return true;
}
// vim like scrolling
if (event->keyval == GDK_KEY_j)
{
layout->scrollRelative(0, 60);
return true;
}
if (event->keyval == GDK_KEY_k)
{
layout->scrollRelative(0, -60);
return true;
}
if (event->keyval == GDK_KEY_h)
{
layout->scrollRelative(-60, 0);
return true;
}
if (event->keyval == GDK_KEY_l)
{
layout->scrollRelative(60, 0);
return true;
}
return false;
}
bool XournalView::onKeyPressEvent(GdkEventKey* event)
{
XOJ_CHECK_TYPE(XournalView);
size_t p = getCurrentPage();
if (p != size_t_npos && p < this->viewPagesLen)
{
PageView* v = this->viewPages[p];
if (v->onKeyPressEvent(event))
{
return true;
}
}
// Esc leaves fullscreen mode
if (event->keyval == GDK_Escape || event->keyval == GDK_F11)
{
if (control->isFullscreen())
{
control->enableFullscreen(false);
return true;
}
}
// F5 starts presentation modus
if (event->keyval == GDK_F5)
{
if (!control->isFullscreen())
{
control->enableFullscreen(true, true);
return true;
}
}
guint state = event->state & gtk_accelerator_get_default_mod_mask();
Layout* layout = gtk_xournal_get_layout(this->widget);
if (state & GDK_SHIFT_MASK)
{
GtkAllocation alloc = { 0 };
gtk_widget_get_allocation(gtk_widget_get_parent(this->widget), &alloc);
int windowHeight = alloc.height - scrollKeySize;
if (event->keyval == GDK_Page_Down)
{
layout->scrollRelativ(0, windowHeight);
return true;
}
if (event->keyval == GDK_Page_Up)
{
layout->scrollRelativ(0, -windowHeight);
return true;
}
}
else
{
if (event->keyval == GDK_Page_Down)
{
control->getScrollHandler()->goToNextPage();
return true;
}
if (event->keyval == GDK_Page_Up)
{
control->getScrollHandler()->goToPreviousPage();
return true;
}
}
if (event->keyval == GDK_Up)
{
if (control->getSettings()->isPresentationMode())
{
control->getScrollHandler()->goToPreviousPage();
return true;
}
else
{
layout->scrollRelativ(0, -scrollKeySize);
return true;
}
}
if (event->keyval == GDK_Down)
{
if (control->getSettings()->isPresentationMode())
{
control->getScrollHandler()->goToNextPage();
return true;
}
else
{
layout->scrollRelativ(0, scrollKeySize);
return true;
}
}
if (event->keyval == GDK_Left)
{
layout->scrollRelativ(-scrollKeySize, 0);
return true;
}
if (event->keyval == GDK_Right)
{
layout->scrollRelativ(scrollKeySize, 0);
return true;
}
if (event->keyval == GDK_End)
{
control->getScrollHandler()->goToLastPage();
return true;
}
if (event->keyval == GDK_Home)
{
control->getScrollHandler()->goToFirstPage();
return true;
}
return false;
}
esp_err_t Storage::writeItem(uint8_t nsIndex, ItemType datatype, const char* key, const void* data, size_t dataSize)
{
if (mState != StorageState::ACTIVE) {
return ESP_ERR_NVS_NOT_INITIALIZED;
}
Page* findPage = nullptr;
Item item;
esp_err_t err;
if (datatype == ItemType::BLOB) {
err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item);
} else {
err = findItem(nsIndex, datatype, key, findPage, item);
}
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) {
return err;
}
if (datatype == ItemType::BLOB) {
VerOffset prevStart, nextStart;
prevStart = nextStart = VerOffset::VER_0_OFFSET;
if (findPage) {
if (findPage->state() == Page::PageState::UNINITIALIZED ||
findPage->state() == Page::PageState::INVALID) {
ESP_ERROR_CHECK(findItem(nsIndex, datatype, key, findPage, item));
}
/* Get the version of the previous index with same <ns,key> */
prevStart = item.blobIndex.chunkStart;
assert(prevStart == VerOffset::VER_0_OFFSET || prevStart == VerOffset::VER_1_OFFSET);
/* Toggle the version by changing the offset */
nextStart
= (prevStart == VerOffset::VER_1_OFFSET) ? VerOffset::VER_0_OFFSET : VerOffset::VER_1_OFFSET;
}
/* Write the blob with new version*/
err = writeMultiPageBlob(nsIndex, key, data, dataSize, nextStart);
if (err == ESP_ERR_NVS_PAGE_FULL) {
return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
}
if (err != ESP_OK) {
return err;
}
if (findPage) {
/* Erase the blob with earlier version*/
err = eraseMultiPageBlob(nsIndex, key, prevStart);
if (err == ESP_ERR_FLASH_OP_FAIL) {
return ESP_ERR_NVS_REMOVE_FAILED;
}
if (err != ESP_OK) {
return err;
}
findPage = nullptr;
} else {
/* Support for earlier versions where BLOBS were stored without index */
err = findItem(nsIndex, datatype, key, findPage, item);
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) {
return err;
}
}
} else {
Page& page = getCurrentPage();
err = page.writeItem(nsIndex, datatype, key, data, dataSize);
if (err == ESP_ERR_NVS_PAGE_FULL) {
if (page.state() != Page::PageState::FULL) {
err = page.markFull();
if (err != ESP_OK) {
return err;
}
}
err = mPageManager.requestNewPage();
if (err != ESP_OK) {
return err;
}
err = getCurrentPage().writeItem(nsIndex, datatype, key, data, dataSize);
if (err == ESP_ERR_NVS_PAGE_FULL) {
return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
}
if (err != ESP_OK) {
return err;
}
} else if (err != ESP_OK) {
return err;
}
}
if (findPage) {
if (findPage->state() == Page::PageState::UNINITIALIZED ||
findPage->state() == Page::PageState::INVALID) {
ESP_ERROR_CHECK(findItem(nsIndex, datatype, key, findPage, item));
}
err = findPage->eraseItem(nsIndex, datatype, key);
if (err == ESP_ERR_FLASH_OP_FAIL) {
return ESP_ERR_NVS_REMOVE_FAILED;
}
if (err != ESP_OK) {
return err;
}
}
#ifndef ESP_PLATFORM
debugCheck();
#endif
return ESP_OK;
}
esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const void* data, size_t dataSize, VerOffset chunkStart)
{
uint8_t chunkCount = 0;
TUsedPageList usedPages;
size_t remainingSize = dataSize;
size_t offset=0;
esp_err_t err = ESP_OK;
/* Check how much maximum data can be accommodated**/
uint32_t max_pages = mPageManager.getPageCount() - 1;
if(max_pages > (Page::CHUNK_ANY-1)/2) {
max_pages = (Page::CHUNK_ANY-1)/2;
}
if (dataSize > max_pages * Page::CHUNK_MAX_SIZE) {
return ESP_ERR_NVS_VALUE_TOO_LONG;
}
do {
Page& page = getCurrentPage();
size_t tailroom = page.getVarDataTailroom();
size_t chunkSize =0;
if (!chunkCount && tailroom < dataSize && tailroom < Page::CHUNK_MAX_SIZE/10) {
/** This is the first chunk and tailroom is too small ***/
if (page.state() != Page::PageState::FULL) {
err = page.markFull();
if (err != ESP_OK) {
return err;
}
}
err = mPageManager.requestNewPage();
if (err != ESP_OK) {
return err;
} else if(getCurrentPage().getVarDataTailroom() == tailroom) {
/* We got the same page or we are not improving.*/
return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
} else {
continue;
}
} else if (!tailroom) {
err = ESP_ERR_NVS_NOT_ENOUGH_SPACE;
break;
}
/* Split the blob into two and store the chunk of available size onto the current page */
assert(tailroom!=0);
chunkSize = (remainingSize > tailroom)? tailroom : remainingSize;
remainingSize -= chunkSize;
err = page.writeItem(nsIndex, ItemType::BLOB_DATA, key,
static_cast<const uint8_t*> (data) + offset, chunkSize, static_cast<uint8_t> (chunkStart) + chunkCount);
chunkCount++;
assert(err != ESP_ERR_NVS_PAGE_FULL);
if (err != ESP_OK) {
break;
} else {
UsedPageNode* node = new UsedPageNode();
node->mPage = &page;
usedPages.push_back(node);
if (remainingSize || (tailroom - chunkSize) < Page::ENTRY_SIZE) {
if (page.state() != Page::PageState::FULL) {
err = page.markFull();
if (err != ESP_OK) {
break;
}
}
err = mPageManager.requestNewPage();
if (err != ESP_OK) {
break;
}
}
}
offset += chunkSize;
if (!remainingSize) {
/* All pages are stored. Now store the index.*/
Item item;
std::fill_n(item.data, sizeof(item.data), 0xff);
item.blobIndex.dataSize = dataSize;
item.blobIndex.chunkCount = chunkCount;
item.blobIndex.chunkStart = chunkStart;
err = getCurrentPage().writeItem(nsIndex, ItemType::BLOB_IDX, key, item.data, sizeof(item.data));
assert(err != ESP_ERR_NVS_PAGE_FULL);
break;
}
} while (1);
if (err != ESP_OK) {
/* Anything failed, then we should erase all the written chunks*/
int ii=0;
for (auto it = std::begin(usedPages); it != std::end(usedPages); it++) {
it->mPage->eraseItem(nsIndex, ItemType::BLOB_DATA, key, ii++);
}
}
usedPages.clearAndFreeNodes();
return err;
}
