GtkWidget * GladeGui::getWindow() {
XOJ_CHECK_TYPE(GladeGui);
return this->window;
}
void XournalView::updateXEvents()
{
XOJ_CHECK_TYPE(XournalView);
gtk_xournal_update_xevent(this->widget);
}
ArrayIterator<PageView*> XournalView::pageViewIterator()
{
XOJ_CHECK_TYPE(XournalView);
return ArrayIterator<PageView*> (viewPages, viewPagesLen);
}
void XournalView::zoomOut()
{
XOJ_CHECK_TYPE(XournalView);
control->getZoomControl()->zoomOut();
}
PdfCache* XournalView::getCache()
{
XOJ_CHECK_TYPE(XournalView);
return this->cache;
}
RepaintHandler* XournalView::getRepaintHandler()
{
XOJ_CHECK_TYPE(XournalView);
return this->repaintHandler;
}
Control* XournalView::getControl()
{
XOJ_CHECK_TYPE(XournalView);
return control;
}
String LoadHandler::getLastError()
{
XOJ_CHECK_TYPE(LoadHandler);
return this->lastError;
}
bool LoadHandler::isAttachedPdfMissing()
{
XOJ_CHECK_TYPE(LoadHandler);
return this->attachedPdfMissing;
}
void LoadHandler::parseBgSolid()
{
XOJ_CHECK_TYPE(LoadHandler);
const char* style = getAttrib("style");
if (strcmp("plain", style) == 0)
{
this->page->setBackgroundType(BACKGROUND_TYPE_NONE);
}
else if (strcmp("lined", style) == 0)
{
this->page->setBackgroundType(BACKGROUND_TYPE_LINED);
}
else if (strcmp("ruled", style) == 0)
{
this->page->setBackgroundType(BACKGROUND_TYPE_RULED);
}
else if (strcmp("graph", style) == 0)
{
this->page->setBackgroundType(BACKGROUND_TYPE_GRAPH);
}
else
{
this->page->setBackgroundType(BACKGROUND_TYPE_NONE);
error(_("Unknown background type parsed: \"%s\""), style);
}
const char* sColor = getAttrib("color");
int color = 0;
if (strcmp("blue", sColor) == 0)
{
color = 0xa0e8ff;
}
else if (strcmp("pink", sColor) == 0)
{
color = 0xffc0d4;
}
else if (strcmp("green", sColor) == 0)
{
color = 0x80FFC0;
}
else if (strcmp("orange", sColor) == 0)
{
color = 0xFFC080;
}
else if (strcmp("yellow", sColor) == 0)
{
color = 0xFFFF80;
}
else if (strcmp("white", sColor) == 0)
{
color = 0xffffff;
}
else
{
parseColor(sColor, color);
}
this->page->setBackgroundColor(color);
}
void LoadHandler::parseBgPdf()
{
XOJ_CHECK_TYPE(LoadHandler);
int pageno = getAttribInt("pageno");
bool attachToDocument = false;
String pdfFilename;
this->page->setBackgroundPdfPageNr(pageno - 1);
if (!this->pdfFilenameParsed)
{
if (this->pdfReplacementFilename.isEmpty())
{
const char* domain = getAttrib("domain");
const char* sFilename = getAttrib("filename");
if (sFilename == NULL)
{
error("PDF Filename missing!");
return;
}
pdfFilename = sFilename;
if (!strcmp("absolute", domain)) // Absolute OR relative path
{
if (!g_file_test(sFilename, G_FILE_TEST_EXISTS))
{
char* dirname = g_path_get_dirname(xournalFilename.c_str());
char* file = g_path_get_basename(sFilename);
char* tmpFilename = g_build_path(G_DIR_SEPARATOR_S, dirname, file, NULL);
if (g_file_test(tmpFilename, G_FILE_TEST_EXISTS))
{
pdfFilename = tmpFilename;
}
g_free(tmpFilename);
g_free(dirname);
g_free(file);
}
}
else if (!strcmp("attach", domain))
{
attachToDocument = true;
char* tmpFilename = g_strdup_printf("%s.%s", xournalFilename.c_str(),
sFilename);
if (g_file_test(tmpFilename, G_FILE_TEST_EXISTS))
{
pdfFilename = tmpFilename;
}
g_free(tmpFilename);
}
else
{
error(_("Unknown domain type: %s"), domain);
return;
}
}
else
{
pdfFilename = this->pdfReplacementFilename;
attachToDocument = this->pdfReplacementAttach;
}
this->pdfFilenameParsed = true;
if (g_file_test(pdfFilename.c_str(), G_FILE_TEST_EXISTS))
{
doc.readPdf(pdfFilename, false, attachToDocument);
if (!doc.getLastErrorMsg().isEmpty())
{
error(_("Error reading PDF: %s"), doc.getLastErrorMsg().c_str());
}
}
else
{
if (attachToDocument)
{
this->attachedPdfMissing = true;
}
else
{
this->pdfMissing = pdfFilename.c_str();
}
}
}
}
bool LoadHandler::closeFile()
{
XOJ_CHECK_TYPE(LoadHandler);
return gzclose(this->fp);
}
GladeGui::operator GdkWindow *() {
XOJ_CHECK_TYPE(GladeGui);
return GTK_WIDGET(getWindow())->window;
}
GladeSearchpath * GladeGui::getGladeSearchPath() {
XOJ_CHECK_TYPE(GladeGui);
return this->gladeSearchPath;
}
int XournalView::getCurrentPage()
{
XOJ_CHECK_TYPE(XournalView);
return currentPage;
}
String LoadHandler::getMissingPdfFilename()
{
XOJ_CHECK_TYPE(LoadHandler);
return this->pdfMissing;
}
bool XournalView::onKeyPressEvent(GdkEventKey* event)
{
XOJ_CHECK_TYPE(XournalView);
int p = getCurrentPage();
if (p >= 0 && 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;
}
void LoadHandler::removePdfBackground()
{
XOJ_CHECK_TYPE(LoadHandler);
this->removePdfBackgroundFlag = true;
}
// send the focus back to the appropriate widget
void XournalView::requestFocus()
{
XOJ_CHECK_TYPE(XournalView);
gtk_widget_grab_focus(this->widget);
}
GtkWidget* SpinPageAdapter::getWidget()
{
XOJ_CHECK_TYPE(SpinPageAdapter);
return this->widget;
}
GtkWidget* XournalView::getWidget()
{
XOJ_CHECK_TYPE(XournalView);
return widget;
}
int SpinPageAdapter::getPage()
{
XOJ_CHECK_TYPE(SpinPageAdapter);
return this->page;
}
void XournalView::pageSizeChanged(int page)
{
XOJ_CHECK_TYPE(XournalView);
layoutPages();
}
void SpinPageAdapter::setMinMaxPage(size_t min, size_t max)
{
XOJ_CHECK_TYPE(SpinPageAdapter);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(this->widget), min, max);
}
double XournalView::getZoom()
{
XOJ_CHECK_TYPE(XournalView);
return control->getZoomControl()->getZoom();
}
void SpinPageAdapter::addListener(SpinPageListener* listener)
{
XOJ_CHECK_TYPE(SpinPageAdapter);
this->listener.push_back(listener);
}
Document* XournalView::getDocument()
{
XOJ_CHECK_TYPE(XournalView);
return control->getDocument();
}
void SpinPageAdapter::removeListener(SpinPageListener* listener)
{
XOJ_CHECK_TYPE(SpinPageAdapter);
this->listener.remove(listener);
}
PagePositionHandler* XournalView::getPagePositionHandler()
{
XOJ_CHECK_TYPE(XournalView);
return this->pagePosition;
}
GladeGui::operator GtkWindow *() {
XOJ_CHECK_TYPE(GladeGui);
return GTK_WINDOW(getWindow());
}
