diff options
Diffstat (limited to 'kdejava/koala/org/kde/koala/KPixmapIO.java')
| -rw-r--r-- | kdejava/koala/org/kde/koala/KPixmapIO.java | 149 |
1 files changed, 149 insertions, 0 deletions
diff --git a/kdejava/koala/org/kde/koala/KPixmapIO.java b/kdejava/koala/org/kde/koala/KPixmapIO.java new file mode 100644 index 00000000..f0e8922c --- /dev/null +++ b/kdejava/koala/org/kde/koala/KPixmapIO.java @@ -0,0 +1,149 @@ +//Auto-generated by kalyptus. DO NOT EDIT. +package org.kde.koala; + +import org.kde.qt.Qt; +import org.kde.qt.QRect; +import org.kde.qt.QtSupport; +import org.kde.qt.QPixmap; +import org.kde.qt.QImage; +import org.kde.qt.QPoint; + +/** + + KPixmapIO implements a fast path for QPixmap to/from QImage conversions. + It uses the MIT-SHM shared memory extension for this. If this extension is + not available, it will fall back to standard Qt methods. + <li><b>Typical usage:</b></li> + You can use KPixmapIO for load/saving pixmaps. + <pre> + KPixmapIO io; + pixmap = io.convertToPixmap(image); + image = io.convertToImage(pixmap); + </pre> + It also has functionality for partially updating/saving pixmaps, see + putImage and getImage. + <b>KPixmapIO vs. Qt speed comparison</b>\n + Speed measurements were taken. These show that usage of KPixmapIO for + images up to a certain threshold size, offers no speed advantage over + the Qt routines. Below you can see a plot of these measurements. + The threshold size, amongst other causes, is determined by the shared + memory allocation policy. If the policy is <code>ShmDontKeep</code>, the + shared memory segment is discarded right after usage, and thus needs to + be allocated before each transfer. This introduces a a setup penalty not + present when the policy is <code>ShmKeepAndGrow.</code> In this case the + shared memory segment is kept and resized when necessary, until the + KPixmapIO object is destroyed. + The default policy is <code>ShmDontKeep.</code> This policy makes sense when + loading pixmaps once. The corresponding threshold is taken at 5.000 + pixels as suggested by experiments. Below this threshold, KPixmapIO + will not use shared memory and fall back on the Qt routines. + When the policy is <code>ShmKeepAndGrow</code>, the threshold is taken at + 2.000 pixels. Using this policy, you might want to use preAllocShm + to pre-allocate a certain amount of shared memory, in order to avoid + resizes. This allocation policy makes sense in a multimedia type + application where you are constantly updating the screen. + Above a couple times the threshold size, KPixmapIO's and Qt's speed become + linear in the number of pixels, KPixmapIO being at least 2, and mostly around + 4 times faster than Qt, depending on the screen and image depth. + Speed difference seems to be the most at 16 bpp, followed by 32 and 24 + bpp respectively. This can be explained by the relatively poor + implementation of 16 bit RGB packing in Qt, while at 32 bpp we need to + transfer more data, and thus gain more, than at 24 bpp. + <li><b>Conclusion:</b></li> + For large pixmaps, there's a definite speed improvement when using + KPixmapIO. On the other hand, there's no speed improvement for small + pixmaps. When you know you're only transferring small pixmaps, there's no + point in using it. + @author Geert Jansen <jansen@kde.org> + + @version $Id$ + + @short Fast QImage to/from QPixmap conversion. + +*/ +public class KPixmapIO implements QtSupport { + private long _qt; + private boolean _allocatedInJavaWorld = true; + protected KPixmapIO(Class dummy){} + + /** + Shared memory allocation policies. + @short Shared memory allocation policies. + */ + public static final int ShmDontKeep = 0; + public static final int ShmKeepAndGrow = 1; + + public KPixmapIO() { + newKPixmapIO(); + } + private native void newKPixmapIO(); + /** + Convert an image to a pixmap. + @param image The image to convert. + @return The pixmap containing the image. + + @short Convert an image to a pixmap. + */ + public native QPixmap convertToPixmap(QImage image); + /** + Convert a pixmap to an image. + @param pixmap The pixmap to convert. + @return The image. + + @short Convert a pixmap to an image. + */ + public native QImage convertToImage(QPixmap pixmap); + /** + Bitblt an image onto a pixmap. + @param dst The destination pixmap. + @param dx Destination x offset. + @param dy Destination y offset. + @param src The image to load. + @short Bitblt an image onto a pixmap. + */ + public native void putImage(QPixmap dst, int dx, int dy, QImage src); + /** + This function is identical to the one above. It only differs in the + arguments it accepts. + @short This function is identical to the one above. + */ + public native void putImage(QPixmap dst, QPoint offset, QImage src); + /** + Transfer (a part of) a pixmap to an image. + @param src The source pixmap. + @param sx Source x offset. + @param sy Source y offset. + @param sw Source width. + @param sh Source height. + @return The image. + + @short Transfer (a part of) a pixmap to an image. + */ + public native QImage getImage(QPixmap src, int sx, int sy, int sw, int sh); + /** + This function is identical to the one above. It only differs in the + arguments it accepts. + @short This function is identical to the one above. + */ + public native QImage getImage(QPixmap src, QRect rect); + /** + Set the shared memory allocation policy. See the introduction for + KPixmapIO for a discussion. + @param policy The alloction policy. + @short Set the shared memory allocation policy. + */ + public native void setShmPolicy(int policy); + /** + Pre-allocate shared memory. KPixmapIO will be able to transfer images + up to this size without resizing. + @param size The size of the image in <code>pixels.</code> + @short Pre-allocate shared memory. + */ + public native void preAllocShm(int size); + /** Deletes the wrapped C++ instance */ + protected native void finalize() throws InternalError; + /** Delete the wrapped C++ instance ahead of finalize() */ + public native void dispose(); + /** Has the wrapped C++ instance been deleted? */ + public native boolean isDisposed(); +} |