void XournalView::layoutPages()
{
XOJ_CHECK_TYPE(XournalView);
Layout* layout = gtk_xournal_get_layout(this->widget);
layout->layoutPages();
}
void XournalView::ensureRectIsVisible(int x, int y, int width, int height)
{
XOJ_CHECK_TYPE(XournalView);
Layout* layout = gtk_xournal_get_layout(this->widget);
layout->ensureRectIsVisible(x, y, width, height);
}
void XournalView::scrollTo(size_t pageNo, double yDocument)
{
XOJ_CHECK_TYPE(XournalView);
if (pageNo == size_t_npos || pageNo >= this->viewPagesLen)
{
return;
}
PageView* v = this->viewPages[pageNo];
Layout* layout = gtk_xournal_get_layout(this->widget);
layout->ensureRectIsVisible(v->layout.getLayoutAbsoluteX(), v->layout.getLayoutAbsoluteY() + yDocument,
v->getDisplayWidth(), v->getDisplayHeight());
}
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::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();
}
void XournalView::pageInserted(size_t page)
{
XOJ_CHECK_TYPE(XournalView);
XojPageView** lastViewPages = this->viewPages;
this->viewPages = new XojPageView *[this->viewPagesLen + 1];
for (size_t i = 0; i < page; i++)
{
this->viewPages[i] = lastViewPages[i];
// unselect to prevent problems...
this->viewPages[i]->setSelected(false);
}
for (size_t i = page; i < this->viewPagesLen; i++)
{
this->viewPages[i + 1] = lastViewPages[i];
// unselect to prevent problems...
this->viewPages[i + 1]->setSelected(false);
}
this->lastSelectedPage = -1;
this->viewPagesLen++;
delete[] lastViewPages;
Document* doc = control->getDocument();
doc->lock();
XojPageView* pageView = new XojPageView(this, doc->getPage(page));
doc->unlock();
this->viewPages[page] = pageView;
Layout* layout = gtk_xournal_get_layout(this->widget);
layout->layoutPages();
layout->updateVisibility();
}
void XournalView::zoomChanged(double lastZoom)
{
XOJ_CHECK_TYPE(XournalView);
Layout* layout = gtk_xournal_get_layout(this->widget);
int currentPage = this->getCurrentPage();
//double pageTop = layout->getVisiblePageTop(currentPage);
double pageTop = 0.0;
layout->layoutPages();
this->scrollTo(currentPage, pageTop);
Document* doc = control->getDocument();
doc->lock();
path file = doc->getEvMetadataFilename();
doc->unlock();
control->getMetadataManager()->setDouble(file, "zoom", getZoom());
this->control->getScheduler()->blockRerenderZoom();
}
void XournalView::scrollTo(size_t pageNo, double yDocument)
{
XOJ_CHECK_TYPE(XournalView);
if (pageNo >= this->viewPagesLen)
{
return;
}
XojPageView* v = this->viewPages[pageNo];
// Make sure it is visible
Layout* layout = gtk_xournal_get_layout(this->widget);
int x = v->getX();
int y = v->getY() + yDocument;
int width = v->getDisplayWidth();
int height = v->getDisplayHeight();
layout->ensureRectIsVisible(x, y, width, height);
// Select the page
control->firePageSelected(pageNo);
}
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;
}
MainWindow::MainWindow(GladeSearchpath * gladeSearchPath, Control * control) :
GladeGui(gladeSearchPath, "main.glade", "mainWindow") {
XOJ_INIT_TYPE(MainWindow);
this->control = control;
this->toolbarIntialized = false;
this->toolbarGroup = NULL;
this->selectedToolbar = NULL;
this->toolbarWidgets = new GtkWidget*[TOOLBAR_DEFINITIONS_LEN];
for (int i = 0; i < TOOLBAR_DEFINITIONS_LEN; i++) {
GtkWidget * w = get(TOOLBAR_DEFINITIONS[i].guiName);
g_object_ref(w);
this->toolbarWidgets[i] = w;
}
this->maximized = false;
this->toolbarMenuData = NULL;
this->toolbarMenuitems = NULL;
GtkWidget * tableXournal = get("tableXournal");
this->xournal = new XournalView(tableXournal, control);
ScrollbarHideType type = control->getSettings()->getScrollbarHideType();
if (type == SCROLLBAR_HIDE_NONE || type == SCROLLBAR_HIDE_VERTICAL) {
Layout * layout = gtk_xournal_get_layout(this->xournal->getWidget());
gtk_table_attach(GTK_TABLE(tableXournal), layout->getScrollbarHorizontal(), 1, 2, 1, 2, (GtkAttachOptions)(
GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
}
setSidebarVisible(control->getSettings()->isSidebarVisible());
// Window handler
g_signal_connect(this->window, "delete-event", (GCallback) & deleteEventCallback, this->control);
g_signal_connect(this->window, "window_state_event", G_CALLBACK(&windowStateEventCallback), this);
g_signal_connect(get("buttonCloseSidebar"), "clicked", G_CALLBACK(buttonCloseSidebarClicked), this);
this->toolbar = new ToolMenuHandler(this->control, this->control->getZoomControl(), this,
this->control->getToolHandler(), GTK_WINDOW(getWindow()));
char * file = gladeSearchPath->findFile(NULL, "toolbar.ini");
ToolbarModel * tbModel = this->toolbar->getModel();
if (!tbModel->parse(file, true)) {
GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(this->window), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, _("Could not parse general toolbar.ini file: %s\nNo Toolbars will be available"), file);
gtk_window_set_transient_for(GTK_WINDOW(dlg), GTK_WINDOW(getWindow()));
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_hide(dlg);
gtk_widget_destroy(dlg);
}
g_free(file);
file = g_build_filename(g_get_home_dir(), G_DIR_SEPARATOR_S, CONFIG_DIR, G_DIR_SEPARATOR_S, TOOLBAR_CONFIG, NULL);
if (g_file_test(file, G_FILE_TEST_EXISTS)) {
if (!tbModel->parse(file, false)) {
GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(this->window), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, _("Could not parse custom toolbar.ini file: %s\nToolbars will not be available"), file);
gtk_window_set_transient_for(GTK_WINDOW(dlg), GTK_WINDOW(this->control->getWindow()->getWindow()));
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_hide(dlg);
gtk_widget_destroy(dlg);
}
}
g_free(file);
initToolbarAndMenu();
GtkWidget * menuViewSidebarVisible = get("menuViewSidebarVisible");
g_signal_connect(menuViewSidebarVisible, "toggled", (GCallback) viewShowSidebar, this);
updateScrollbarSidebarPosition();
gtk_window_set_default_size(GTK_WINDOW(this->window), control->getSettings()->getMainWndWidth(),
control->getSettings()->getMainWndHeight());
if (control->getSettings()->isMainWndMaximized()) {
gtk_window_maximize(GTK_WINDOW(this->window));
} else {
gtk_window_unmaximize(GTK_WINDOW(this->window));
}
getSpinPageNo()->addListener(this->control->getScrollHandler());
// Drag and Drop
g_signal_connect(this->window, "drag-data-received", G_CALLBACK(dragDataRecived), this);
gtk_drag_dest_set(this->window, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets(this->window);
gtk_drag_dest_add_image_targets(this->window);
gtk_drag_dest_add_text_targets(this->window);
}
Layout * MainWindow::getLayout() {
XOJ_CHECK_TYPE(MainWindow);
Layout * layout = gtk_xournal_get_layout(GTK_WIDGET(this->xournal->getWidget()));
return layout;
}
