From 4002d292bbb499304af30bc060ce0200481062b8 Mon Sep 17 00:00:00 2001 From: Nicolas Dufour Date: Tue, 19 Mar 2013 08:01:10 +0100 Subject: Partial fix for Bug #1071082 (Undo History doesn't work if open before file is opened) by vaifrax. (bzr r12225) --- src/desktop.cpp | 7 +++++++ src/event-log.cpp | 13 ++++++++++++- 2 files changed, 19 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/desktop.cpp b/src/desktop.cpp index c7a763ae1..d74e8fdad 100644 --- a/src/desktop.cpp +++ b/src/desktop.cpp @@ -1582,6 +1582,13 @@ SPDesktop::setDocument (SPDocument *doc) _layer_hierarchy->connectChanged(sigc::bind(sigc::ptr_fun(_layer_hierarchy_changed), this)); _layer_hierarchy->setTop(doc->getRoot()); + // remove old EventLog if it exists (see also: bug #1071082) + if (event_log) { + doc->removeUndoObserver(*event_log); + delete event_log; + event_log = 0; + } + /* setup EventLog */ event_log = new Inkscape::EventLog(doc); doc->addUndoObserver(*event_log); diff --git a/src/event-log.cpp b/src/event-log.cpp index e2528ce0b..9304f68c5 100644 --- a/src/event-log.cpp +++ b/src/event-log.cpp @@ -38,7 +38,18 @@ EventLog::EventLog(SPDocument* document) : curr_row[_columns.type] = SP_VERB_FILE_NEW; } -EventLog::~EventLog() { } +EventLog::~EventLog() { + // avoid crash by clearing entries here (see bug #1071082) + if (_connected) { + (*_callback_connections)[CALLB_SELECTION_CHANGE].block(); + (*_callback_connections)[CALLB_EXPAND].block(); + + _event_list_store->clear(); + + (*_callback_connections)[CALLB_EXPAND].block(false); + (*_callback_connections)[CALLB_SELECTION_CHANGE].block(false); + } +} void EventLog::notifyUndoEvent(Event* log) -- cgit v1.2.3 From 6febb5a75ac5b7d8b41c4cf6c49799c094b98199 Mon Sep 17 00:00:00 2001 From: Jasper van de Gronde Date: Thu, 21 Mar 2013 12:15:43 +0100 Subject: Handle bitmap downsampling ourselves, see bug #804162 in launchpad. (bzr r12227) --- src/display/drawing-image.cpp | 124 ++++++++++++++++++++++++++++++++++++++---- src/display/drawing-image.h | 3 + 2 files changed, 115 insertions(+), 12 deletions(-) (limited to 'src') diff --git a/src/display/drawing-image.cpp b/src/display/drawing-image.cpp index 0c8ac9681..185b62285 100644 --- a/src/display/drawing-image.cpp +++ b/src/display/drawing-image.cpp @@ -22,6 +22,7 @@ DrawingImage::DrawingImage(Drawing &drawing) : DrawingItem(drawing) , _pixbuf(NULL) , _surface(NULL) + , _new_surface(NULL) , _style(NULL) {} @@ -30,6 +31,7 @@ DrawingImage::~DrawingImage() if (_style) sp_style_unref(_style); if (_pixbuf) { + if (_new_surface) cairo_surface_destroy(_new_surface); cairo_surface_destroy(_surface); g_object_unref(_pixbuf); } @@ -118,26 +120,124 @@ unsigned DrawingImage::_renderItem(DrawingContext &ct, Geom::IntRect const &/*ar if (!outline) { if (!_pixbuf) return RENDER_OK; - + Inkscape::DrawingContext::Save save(ct); ct.transform(_ctm); ct.newPath(); ct.rectangle(_clipbox); ct.clip(); - ct.translate(_origin); - ct.scale(_scale); - ct.setSource(_surface, 0, 0); + ///////////////////////////////////////////////////////////////////////////// + // BEGIN: Hack to avoid Cairo bug + // The total transform (which is RIGHT-multiplied with the item points to get display points) equals: + // scale*translate_origin*_ctm = scale*translate(origin)*expansion*expansionInv*_ctm + // = scale*expansion*translate(origin*expansion)*expansionInv*_ctm + // To avoid a Cairo bug, we handle the scale*expansion part ourselves. + // See https://bugs.launchpad.net/inkscape/+bug/804162 + + Geom::Scale expansion(_ctm.expansion()); + int orgwidth = cairo_image_surface_get_width(_surface); + int orgheight = cairo_image_surface_get_height(_surface); + + if (_scale[Geom::X]*expansion[Geom::X]*orgwidth*255.0<1.0 || _scale[Geom::Y]*expansion[Geom::Y]*orgheight*255.0<1.0) { + // Resized image too small to actually see anything + return RENDER_OK; + } + + // Split scale*expansion in a part that is <= 1.0 and a part that is >= 1.0. We only take care of the part <= 1.0. + Geom::Scale scaleExpansionSmall(std::min(fabs(_scale[Geom::X]*expansion[Geom::X]),1),std::min(fabs(_scale[Geom::Y]*expansion[Geom::Y]),1)); + Geom::Scale scaleExpansionLarge(_scale[Geom::X]*expansion[Geom::X]/scaleExpansionSmall[Geom::X],_scale[Geom::Y]*expansion[Geom::Y]/scaleExpansionSmall[Geom::Y]); + + Geom::Point newSize(Geom::Point(orgwidth,orgheight)*scaleExpansionSmall); + if ((newSize-Geom::Point(orgwidth,orgheight)).length()<0.1) { + // Just use _surface directly. + ct.scale(expansion.inverse()); // This should not include scale (see derivation above) + ct.translate(_origin*expansion); + ct.scale(scaleExpansionLarge); + ct.setSource(_surface, 0, 0); + } else if (!_new_surface || (newSize-_rescaledSize).length()>0.1) { + // Rescaled image is sufficiently different from cached image to recompute + if (_new_surface) cairo_surface_destroy(_new_surface); + _rescaledSize = newSize; + + // This essentially considers an image to be composed of rectangular pixels and computes the least-squares approximation of the original. + // When the scale factor is really large or small this essentially results in using a box filter, while for scale factors approaching 1 it is more like a "tent" kernel. + int newwidth = static_cast(floor(orgwidth*scaleExpansionSmall[Geom::X])+1); + int newheight = static_cast(floor(orgheight*scaleExpansionSmall[Geom::Y])+1); + std::vector xBegin(newwidth, -1), yBegin(newheight, -1); + std::vector< std::vector > xCoefs(xBegin.size()), yCoefs(yBegin.size()); + for(int x=0; x(scaleExpansionSmall[Geom::X]); // x-coord in target coordinates where the current source pixel begins + double coordEnd = (x+1)*static_cast(scaleExpansionSmall[Geom::X]); // x-coord in target coordinates where the current source pixel ends + int begin = static_cast(floor(coordBegin)); // First pixel (x-coord) affected by the current source pixel + int end = static_cast(ceil(coordEnd)); // First pixel (x-coord) NOT affected by the current source pixel (a zero contribution is counted as not affecting the pixel) + for(int nx=begin; nx(std::min(nx+1,coordEnd) - std::max(nx,coordBegin))); + } + } + for(int y=0; y(scaleExpansionSmall[Geom::Y]); // y-coord in target coordinates where the current source pixel begins + double coordEnd = (y+1)*static_cast(scaleExpansionSmall[Geom::Y]); // y-coord in target coordinates where the current source pixel ends + int begin = static_cast(floor(coordBegin)); // First pixel (y-coord) affected by the current source pixel + int end = static_cast(ceil(coordEnd)); // First pixel (y-coord) NOT affected by the current source pixel (a zero contribution is counted as not affecting the pixel) + for(int ny=begin; ny(std::min(ny+1,coordEnd) - std::max(ny,coordBegin))); + } + } + + _new_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, newwidth,newheight); + unsigned char * orgdata = cairo_image_surface_get_data(_surface); + unsigned char * newdata = cairo_image_surface_get_data(_new_surface); + int orgstride = cairo_image_surface_get_stride(_surface); + int newstride = cairo_image_surface_get_stride(_new_surface); + + cairo_surface_flush(_surface); + cairo_surface_flush(_new_surface); + + for(int y=0; y(yCoefs[y].size()); oy++) { + for(int ox=0; ox(xCoefs[x].size()); ox++) { + for(int c=0; c<4; c++) { + tempSum[c] += xCoefs[x][ox]*yCoefs[y][oy]*orgdata[c+4*(xBegin[x]+ox)+orgstride*(yBegin[y]+oy)]; + } + } + } + for(int c=0; c<4; c++) { + newdata[c+4*x+newstride*y] = static_cast(tempSum[c]); + } + } + } + + cairo_surface_mark_dirty(_new_surface); + + ct.scale(expansion.inverse()); // This should not include scale (see derivation above) + ct.translate(_origin*expansion); + ct.scale(scaleExpansionLarge); + ct.setSource(_new_surface, 0, 0); + } else { + // No need to regenerate, but we do draw from _new_surface. + ct.scale(expansion.inverse()); // This should not include scale (see derivation above) + ct.translate(_origin*expansion); + ct.scale(scaleExpansionLarge); + ct.setSource(_new_surface, 0, 0); + } + + // END: Hack to avoid Cairo bug + ///////////////////////////////////////////////////////////////////////////// - cairo_matrix_t tt; - Geom::Affine total; - cairo_get_matrix(ct.raw(), &tt); - ink_matrix_to_2geom(total, tt); + // TODO: If Cairo's problems are gone, uncomment the following: + //ct.translate(_origin); + //ct.scale(_scale); + //ct.setSource(_surface, 0, 0); - if (total.expansionX() > 1.0 || total.expansionY() > 1.0) { - cairo_pattern_t *p = cairo_get_source(ct.raw()); - cairo_pattern_set_filter(p, CAIRO_FILTER_NEAREST); - } //ct.paint(_opacity); ct.paint(); diff --git a/src/display/drawing-image.h b/src/display/drawing-image.h index 306096d0e..593185c97 100644 --- a/src/display/drawing-image.h +++ b/src/display/drawing-image.h @@ -45,6 +45,9 @@ protected: cairo_surface_t *_surface; SPStyle *_style; + cairo_surface_t *_new_surface; // Part of hack around Cairo bug + Geom::Point _rescaledSize; // Part of hack around Cairo bug + // TODO: the following three should probably be merged into a new Geom::Viewbox object Geom::Rect _clipbox; ///< for preserveAspectRatio Geom::Point _origin; -- cgit v1.2.3 From 787604447932202d97e7e9d4fcd3bec5403417d9 Mon Sep 17 00:00:00 2001 From: Jasper van de Gronde Date: Thu, 21 Mar 2013 12:24:40 +0100 Subject: Clarified choice of downsampling routine. (bzr r12228) --- src/display/drawing-image.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/display/drawing-image.cpp b/src/display/drawing-image.cpp index 185b62285..2bfd71713 100644 --- a/src/display/drawing-image.cpp +++ b/src/display/drawing-image.cpp @@ -160,8 +160,10 @@ unsigned DrawingImage::_renderItem(DrawingContext &ct, Geom::IntRect const &/*ar if (_new_surface) cairo_surface_destroy(_new_surface); _rescaledSize = newSize; - // This essentially considers an image to be composed of rectangular pixels and computes the least-squares approximation of the original. + // This essentially considers an image to be composed of rectangular pixels (box kernel) and computes the least-squares approximation of the original. // When the scale factor is really large or small this essentially results in using a box filter, while for scale factors approaching 1 it is more like a "tent" kernel. + // Although the quality of the result is not great, it is typically better than an ordinary box filter, and it is guaranteed to preserve the overall brightness of the image. + // The best improvement would probably be to do the same kind of thing based on a tent kernel, but that's quite a bit more complicated, and probably not worth the trouble for a hack like this. int newwidth = static_cast(floor(orgwidth*scaleExpansionSmall[Geom::X])+1); int newheight = static_cast(floor(orgheight*scaleExpansionSmall[Geom::Y])+1); std::vector xBegin(newwidth, -1), yBegin(newheight, -1); -- cgit v1.2.3