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;
}
}
