void SidebarToolbar::btDownClicked(GtkToolButton* toolbutton, SidebarToolbar* toolbar) { XOJ_CHECK_TYPE_OBJ(toolbar, SidebarToolbar); Document* doc = toolbar->control->getDocument(); PageRef swapped_page, other_page; doc->lock(); size_t page = doc->indexOf(toolbar->currentPage); swapped_page = toolbar->currentPage; other_page = doc->getPage(page + 1); if (page != size_t_npos) { doc->deletePage(page); doc->insertPage(toolbar->currentPage, page + 1); } doc->unlock(); UndoRedoHandler* undo = toolbar->control->getUndoRedoHandler(); undo->addUndoAction(new SwapUndoAction(page, false, swapped_page, other_page)); toolbar->control->firePageDeleted(page); toolbar->control->firePageInserted(page + 1); toolbar->control->firePageSelected(page + 1); toolbar->control->getScrollHandler()->scrollToPage(page + 1); }
bool MetadataManager::save(MetadataManager* manager) { XOJ_CHECK_TYPE_OBJ(manager, MetadataManager); manager->timeoutId = 0; manager->cleanupMetadata(); gsize length = 0; char* data = g_key_file_to_data(manager->config, &length, NULL); char* fileName = FILENAME(); GFile* file = g_file_new_for_path(fileName); if (!g_file_replace_contents(file, data, length, NULL, false, G_FILE_CREATE_PRIVATE, NULL, NULL, NULL)) { g_warning("could not write metadata file: %s", fileName); } g_free(data); g_free(fileName); g_object_unref(file); return false; }
gboolean SettingsDialog::zoomcallibSliderChanged(GtkRange * range, GtkScrollType scroll, gdouble value, SettingsDialog * dlg) { XOJ_CHECK_TYPE_OBJ(dlg, SettingsDialog); dlg->setDpi((int) value); return false; }
gboolean Settings::saveCallback(Settings* data) { XOJ_CHECK_TYPE_OBJ(data, Settings); ((Settings*) data)->save(); return false; }
void SelectBackgroundColorDialog::buttonCustomCallback(GtkButton* button, SelectBackgroundColorDialog* dlg) { XOJ_CHECK_TYPE_OBJ(dlg, SelectBackgroundColorDialog); dlg->selected = -2; gtk_widget_hide(dlg->window); }
void AbstractToolItem::toolButtonCallback(GtkToolButton* toolbutton, AbstractToolItem* item) { XOJ_CHECK_TYPE_OBJ(item, AbstractToolItem); if (toolbutton && GTK_IS_TOGGLE_TOOL_BUTTON(toolbutton)) { bool selected = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton)); // ignore this event... GTK Broadcast to much events, e.g. if you call set_active if (item->toolToggleButtonActive == selected) { return; } // don't allow deselect this button if (item->toolToggleOnlyEnable && selected == false) { gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton), true); return; } item->toolToggleButtonActive = selected; } item->activated(NULL, NULL, toolbutton); }
bool SidebarIndexPage::searchTimeoutFunc(SidebarIndexPage* sidebar) { XOJ_CHECK_TYPE_OBJ(sidebar, SidebarIndexPage); sidebar->searchTimeout = 0; treeBookmarkSelected(sidebar->treeViewBookmarks, sidebar); return false; }
void MainWindow::viewShowSidebar(GtkCheckMenuItem * checkmenuitem, MainWindow * win) { XOJ_CHECK_TYPE_OBJ(win, MainWindow); bool a = gtk_check_menu_item_get_active(checkmenuitem); if (win->control->getSettings()->isSidebarVisible() == a) { return; } win->setSidebarVisible(a); }
void RecentManager::recentsMenuActivateCallback(GtkAction * action, RecentManager * recentManager) { XOJ_CHECK_TYPE_OBJ(recentManager, RecentManager); GtkRecentInfo * info = (GtkRecentInfo *) g_object_get_data(G_OBJECT (action), "gtk-recent-info"); g_return_if_fail(info != NULL); const char * uri = gtk_recent_info_get_uri(info); recentManager->openRecent(uri); }
bool SpinPageAdapter::pageNrSpinChangedTimerCallback(SpinPageAdapter* adapter) { XOJ_CHECK_TYPE_OBJ(adapter, SpinPageAdapter); adapter->lastTimeoutId = 0; adapter->page = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(adapter->widget)); adapter->firePageChanged(); return false; }
void SElement::setComment(const String name, const String comment) { XOJ_CHECK_TYPE(SElement); SAttribute& attrib = this->element->attributes[name]; XOJ_CHECK_TYPE_OBJ(&attrib, SAttribute); attrib.comment = comment; }
bool SynchronizedProgressListener::setCurrentCallback(SynchronizedProgressListener * listener) { XOJ_CHECK_TYPE_OBJ(listener, SynchronizedProgressListener); gdk_threads_enter(); listener->target->setCurrentState(listener->current); gdk_threads_leave(); listener->currentIdleId = 0; return false; // do not call again }
void SElement::setDouble(const String name, const double value) { XOJ_CHECK_TYPE(SElement); SAttribute& attrib = this->element->attributes[name]; XOJ_CHECK_TYPE_OBJ(&attrib, SAttribute); attrib.dValue = value; attrib.type = ATTRIBUTE_TYPE_DOUBLE; }
void RenderJob::rerenderRectangle(RenderJob * renderJob, Rectangle * rect) { XOJ_CHECK_TYPE_OBJ(renderJob, RenderJob); PageView * view = renderJob->view; double zoom = view->xournal->getZoom(); Document * doc = view->xournal->getDocument(); doc->lock(); double pageWidth = view->page.getWidth(); double pageHeight = view->page.getHeight(); doc->unlock(); int x = rect->x * zoom; int y = rect->y * zoom; int width = rect->width * zoom; int height = rect->height * zoom; cairo_surface_t * rectBuffer = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t * crRect = cairo_create(rectBuffer); cairo_translate(crRect, -x, -y); cairo_scale(crRect, zoom, zoom); DocumentView v; v.limitArea(rect->x, rect->y, rect->width, rect->height); if (view->page.getBackgroundType() == BACKGROUND_TYPE_PDF) { int pgNo = view->page.getPdfPageNr(); XojPopplerPage * popplerPage = doc->getPdfPage(pgNo); PdfCache * cache = view->xournal->getCache(); PdfView::drawPage(cache, popplerPage, crRect, zoom, pageWidth, pageHeight); } doc->lock(); v.drawPage(view->page, crRect, false); doc->unlock(); cairo_destroy(crRect); g_mutex_lock(view->drawingMutex); cairo_t * crPageBuffer = cairo_create(view->crBuffer); cairo_set_operator(crPageBuffer, CAIRO_OPERATOR_SOURCE); cairo_set_source_surface(crPageBuffer, rectBuffer, x, y); cairo_rectangle(crPageBuffer, x, y, width, height); cairo_fill(crPageBuffer); cairo_destroy(crPageBuffer); cairo_surface_destroy(rectBuffer); g_mutex_unlock(view->drawingMutex); }
void SElement::setBool(const String name, const bool value) { XOJ_CHECK_TYPE(SElement); SAttribute& attrib = this->element->attributes[name]; XOJ_CHECK_TYPE_OBJ(&attrib, SAttribute); attrib.iValue = value; attrib.type = ATTRIBUTE_TYPE_BOOLEAN; }
void SElement::setString(const String name, const String value) { XOJ_CHECK_TYPE(SElement); SAttribute& attrib = this->element->attributes[name]; XOJ_CHECK_TYPE_OBJ(&attrib, SAttribute); attrib.sValue = value; attrib.type = ATTRIBUTE_TYPE_STRING; }
void ToolPageLayer::cbSelectCallback(GtkComboBox* widget, ToolPageLayer* tpl) { XOJ_CHECK_TYPE_OBJ(tpl, ToolPageLayer); if (tpl->inCbUpdate) { return; } tpl->handler->actionPerformed(ACTION_FOOTER_LAYER, GROUP_NOGROUP, NULL, NULL, NULL, true); }
void SElement::setInt(const String name, const int value) { XOJ_CHECK_TYPE(SElement); SAttribute& attrib = this->element->attributes[name]; XOJ_CHECK_TYPE_OBJ(&attrib, SAttribute); attrib.iValue = value; attrib.type = ATTRIBUTE_TYPE_INT_HEX; }
void Sidebar::buttonClicked(GtkToolButton * toolbutton, SidebarPageButton * buttonData) { XOJ_CHECK_TYPE_OBJ(buttonData->sidebar, Sidebar); if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton))) { if (buttonData->sidebar->visiblePage != buttonData->page->getWidget()) { buttonData->sidebar->setSelectedPage(buttonData->index); } } else if (buttonData->sidebar->visiblePage == buttonData->page->getWidget()) { gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton), true); } }
cairo_status_t TexImage::cairoReadFunction(TexImage * image, unsigned char * data, unsigned int length) { XOJ_CHECK_TYPE_OBJ(image, TexImage); for (int i = 0; i < length; i++, image->read++) { if (image->read >= image->dLen) { return CAIRO_STATUS_READ_ERROR; } data[i] = image->data[image->read]; } return CAIRO_STATUS_SUCCESS; }
bool Job::callAfterCallback(Job * job) { XOJ_CHECK_TYPE_OBJ(job, Job); gdk_threads_enter(); job->afterRun(); gdk_threads_leave(); job->afterRunId = 0; job->unref(); return false; // do not call again }
bool MainWindow::windowStateEventCallback(GtkWidget * window, GdkEventWindowState * event, MainWindow * win) { XOJ_CHECK_TYPE_OBJ(win, MainWindow); if (!(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) { gboolean maximized; maximized = event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED; win->setMaximized(maximized); } return false; }
cairo_surface_t * PdfCache::lookup(XojPopplerPage * popplerPage) { XOJ_CHECK_TYPE(PdfCache); for (GList * l = this->data; l != NULL; l = l->next) { PdfCacheEntry * e = (PdfCacheEntry *) l->data; XOJ_CHECK_TYPE_OBJ(e, PdfCacheEntry); if (e->popplerPage == popplerPage) { return e->rendered; } } return NULL; }
ExportDialog::ExportDialog(GladeSearchpath* gladeSearchPath) : GladeGui(gladeSearchPath, "exportSettings.glade", "exportDialog") { XOJ_INIT_TYPE(ExportDialog); gtk_spin_button_set_value(GTK_SPIN_BUTTON(get("spDpi")), 300); g_signal_connect(get("rdRangePages"), "toggled", G_CALLBACK( +[](GtkToggleButton* togglebutton, ExportDialog* self) { XOJ_CHECK_TYPE_OBJ(self, ExportDialog); gtk_widget_set_sensitive(self->get("txtPages"), gtk_toggle_button_get_active(togglebutton)); }), this); }
/** * If the Scheduler is blocking because we are zooming and there are only render jobs * we need to wakeup it later */ bool Scheduler::jobRenderThreadTimer(Scheduler * scheduler) { XOJ_CHECK_TYPE_OBJ(scheduler, Scheduler); scheduler->jobRenderThreadTimerId = 0; g_mutex_lock(scheduler->blockRenderMutex); g_free(scheduler->blockRenderZoomTime); scheduler->blockRenderZoomTime = NULL; g_mutex_unlock(scheduler->blockRenderMutex); g_cond_broadcast(scheduler->jobQueueCond); return false; }
void XournalView::onRealized(GtkWidget* widget, XournalView* view) { XOJ_CHECK_TYPE_OBJ(view, XournalView); // Disable event compression if (gtk_widget_get_realized(view->getWidget())) { gdk_window_set_event_compression(gtk_widget_get_window(view->getWidget()), false); } else { g_warning("could not disable event compression"); } }
void Scrollbar::scrolled(GtkAdjustment * adjustment, Scrollbar * scrollbar) { XOJ_CHECK_TYPE_OBJ(scrollbar, Scrollbar); if (scrollbar->value == scrollbar->getValue()) { return; } scrollbar->value = scrollbar->getValue(); GList * l = scrollbar->listener; for (; l != NULL; l = l->next) { ScrollbarListener * listener = (ScrollbarListener *) l->data; listener->scrolled(scrollbar); } }
gboolean XournalView::clearMemoryTimer(XournalView* widget) { XOJ_CHECK_TYPE_OBJ(widget, XournalView); GList* list = NULL; for (size_t i = 0; i < widget->viewPagesLen; i++) { XojPageView* v = widget->viewPages[i]; if (v->getLastVisibleTime() > 0) { list = g_list_insert_sorted(list, v, (GCompareFunc) pageViewCmpSize); } } int pixel = 2884560; int firstPages = 4; int i = 0; for (GList* l = list; l != NULL; l = l->next) { if (firstPages) { firstPages--; } else { XojPageView* v = (XojPageView*) l->data; if (pixel <= 0) { v->deleteViewBuffer(); } else { pixel -= v->getBufferPixels(); } } i++; } g_list_free(list); // call again return true; }
bool SidebarPreviewBase::scrollToPreview(SidebarPreviewBase* sidebar) { XOJ_CHECK_TYPE_OBJ(sidebar, SidebarPreviewBase); if (!sidebar->enabled) { return false; } MainWindow* win = sidebar->control->getWindow(); if (win == NULL) { return false; } GtkWidget* w = win->get("sidebar"); if (!gtk_widget_get_visible(w)) { return false; } if (sidebar->selectedEntry != size_t_npos && sidebar->selectedEntry < sidebar->previews.size()) { SidebarPreviewBaseEntry* p = sidebar->previews[sidebar->selectedEntry]; // scroll to preview GtkAdjustment* hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(sidebar->scrollPreview)); GtkAdjustment* vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sidebar->scrollPreview)); GtkWidget* widget = p->getWidget(); GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); int x = allocation.x; int y = allocation.y; if (x == -1) { g_idle_add((GSourceFunc) scrollToPreview, sidebar); return false; } gtk_adjustment_clamp_page(vadj, y, y + allocation.height); gtk_adjustment_clamp_page(hadj, x, x + allocation.width); } return false; }
void SidebarPreviewBase::sizeChanged(GtkWidget* widget, GtkAllocation* allocation, SidebarPreviewBase* sidebar) { XOJ_CHECK_TYPE_OBJ(sidebar, SidebarPreviewBase); static int lastWidth = -1; if (lastWidth == -1) { lastWidth = allocation->width; } if (ABS(lastWidth - allocation->width) > 20) { sidebar->layout(); lastWidth = allocation->width; } }