author | alwin <alwin> | 2004-04-14 20:50:42 (UTC) |
---|---|---|
committer | alwin <alwin> | 2004-04-14 20:50:42 (UTC) |
commit | fe6808b41795d1b6000932bf84d74dbd24c4ed95 (patch) (unidiff) | |
tree | aa351edbbd788708629cf4ad45f617e891c534a6 /libopie2/opiemm/oimagescrollview.cpp | |
parent | a9c1e1a5903f4cf21bcbd5ffd1df46c8211ca502 (diff) | |
download | opie-fe6808b41795d1b6000932bf84d74dbd24c4ed95.zip opie-fe6808b41795d1b6000932bf84d74dbd24c4ed95.tar.gz opie-fe6808b41795d1b6000932bf84d74dbd24c4ed95.tar.bz2 |
added the image-display widgets to lib 'cause it may used in other
applications
ToDo: Interface description
Diffstat (limited to 'libopie2/opiemm/oimagescrollview.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | libopie2/opiemm/oimagescrollview.cpp | 585 |
1 files changed, 585 insertions, 0 deletions
diff --git a/libopie2/opiemm/oimagescrollview.cpp b/libopie2/opiemm/oimagescrollview.cpp new file mode 100644 index 0000000..0e86bd0 --- a/dev/null +++ b/libopie2/opiemm/oimagescrollview.cpp | |||
@@ -0,0 +1,585 @@ | |||
1 | #include "oimagescrollview.h" | ||
2 | |||
3 | #include <opie2/oimagezoomer.h> | ||
4 | #include <opie2/odebug.h> | ||
5 | #include <opie2/oapplication.h> | ||
6 | #include <opie2/owait.h> | ||
7 | |||
8 | #include <qimage.h> | ||
9 | #include <qlayout.h> | ||
10 | #include <qpe/qcopenvelope_qws.h> | ||
11 | |||
12 | /* for usage with the bitset */ | ||
13 | #define AUTO_SCALE 0 | ||
14 | #define AUTO_ROTATE 1 | ||
15 | #define SHOW_ZOOMER 2 | ||
16 | #define FIRST_RESIZE_DONE 3 | ||
17 | #define IMAGE_IS_JPEG 4 | ||
18 | #define IMAGE_SCALED_LOADED 5 | ||
19 | |||
20 | #define SCROLLVIEW_BITSET_SIZE 6 | ||
21 | |||
22 | namespace Opie { | ||
23 | namespace MM { | ||
24 | OImageScrollView::OImageScrollView( QWidget* parent, const char* name, WFlags f ) | ||
25 | :QScrollView(parent,name,f|Qt::WRepaintNoErase ),_image_data(),_original_data(), | ||
26 | m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("") | ||
27 | { | ||
28 | _zoomer = 0; | ||
29 | m_states[AUTO_SCALE]=true; | ||
30 | m_states[AUTO_ROTATE]=true; | ||
31 | m_states[FIRST_RESIZE_DONE]=false; | ||
32 | m_states[IMAGE_IS_JPEG]=false; | ||
33 | m_states[IMAGE_SCALED_LOADED]=false; | ||
34 | m_states[SHOW_ZOOMER]=true; | ||
35 | init(); | ||
36 | } | ||
37 | |||
38 | OImageScrollView::OImageScrollView (const QImage&img, QWidget * parent, const char * name, WFlags f,bool always_scale,bool rfit) | ||
39 | :QScrollView(parent,name,f|Qt::WRepaintNoErase),_image_data(),_original_data(img), | ||
40 | m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("") | ||
41 | { | ||
42 | _zoomer = 0; | ||
43 | m_states[AUTO_SCALE]=always_scale; | ||
44 | m_states[AUTO_ROTATE]=rfit; | ||
45 | m_states[FIRST_RESIZE_DONE]=false; | ||
46 | m_states[IMAGE_IS_JPEG]=false; | ||
47 | m_states[IMAGE_SCALED_LOADED]=false; | ||
48 | m_states[SHOW_ZOOMER]=true; | ||
49 | _original_data.convertDepth(QPixmap::defaultDepth()); | ||
50 | _original_data.setAlphaBuffer(false); | ||
51 | init(); | ||
52 | } | ||
53 | |||
54 | OImageScrollView::OImageScrollView (const QString&img, QWidget * parent, const char * name, WFlags f,bool always_scale,bool rfit) | ||
55 | :QScrollView(parent,name,f|Qt::WRepaintNoErase),_image_data(),_original_data(),m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("") | ||
56 | { | ||
57 | _zoomer = 0; | ||
58 | m_states.resize(SCROLLVIEW_BITSET_SIZE); | ||
59 | m_states[AUTO_SCALE]=always_scale; | ||
60 | m_states[AUTO_ROTATE]=rfit; | ||
61 | m_states[FIRST_RESIZE_DONE]=false; | ||
62 | m_states[IMAGE_IS_JPEG]=false; | ||
63 | m_states[IMAGE_SCALED_LOADED]=false; | ||
64 | m_states[SHOW_ZOOMER]=true; | ||
65 | init(); | ||
66 | setImage(img); | ||
67 | } | ||
68 | |||
69 | void OImageScrollView::setImage(const QImage&img) | ||
70 | { | ||
71 | _image_data = QImage(); | ||
72 | _original_data=img; | ||
73 | _original_data.convertDepth(QPixmap::defaultDepth()); | ||
74 | _original_data.setAlphaBuffer(false); | ||
75 | m_lastName = ""; | ||
76 | setImageIsJpeg(false); | ||
77 | setImageScaledLoaded(false); | ||
78 | if (FirstResizeDone()) { | ||
79 | generateImage(); | ||
80 | } | ||
81 | } | ||
82 | |||
83 | void OImageScrollView::loadJpeg(bool interncall) | ||
84 | { | ||
85 | if (m_lastName.isEmpty()) return; | ||
86 | QImageIO iio( m_lastName, 0l ); | ||
87 | QString param; | ||
88 | bool real_load = false; | ||
89 | if (AutoScale()) { | ||
90 | if (!interncall) { | ||
91 | int wid, hei; | ||
92 | wid = QApplication::desktop()->width(); | ||
93 | hei = QApplication::desktop()->height(); | ||
94 | if (hei>wid) { | ||
95 | wid = hei; | ||
96 | } else { | ||
97 | hei = wid; | ||
98 | } | ||
99 | param = QString( "Fast Shrink( 7 ) Scale( %1, %2, ScaleFree)" ).arg( wid ).arg( hei ); | ||
100 | odebug << "Load jpeg scaled \"" << param << "\"" << oendl; | ||
101 | iio.setParameters(param.latin1()); | ||
102 | setImageScaledLoaded(true); | ||
103 | real_load = true; | ||
104 | } | ||
105 | } else { | ||
106 | if (ImageScaledLoaded()||!interncall) { | ||
107 | odebug << "Load jpeg unscaled" << oendl; | ||
108 | real_load = true; | ||
109 | } | ||
110 | setImageScaledLoaded(false); | ||
111 | } | ||
112 | if (real_load) { | ||
113 | { | ||
114 | QCopEnvelope( "QPE/System", "busy()" ); | ||
115 | } | ||
116 | _original_data = iio.read() ? iio.image() : QImage(); | ||
117 | { | ||
118 | QCopEnvelope env( "QPE/System", "notBusy(QString)" ); | ||
119 | env << "Image loaded"; | ||
120 | } | ||
121 | } | ||
122 | } | ||
123 | |||
124 | void OImageScrollView::setImage( const QString& path ) { | ||
125 | odebug << "load new image " << oendl; | ||
126 | if (m_lastName == path) return; | ||
127 | m_lastName = path; | ||
128 | QString itype = QImage::imageFormat(m_lastName); | ||
129 | odebug << "Image type = " << itype << oendl; | ||
130 | if (itype == "JPEG") { | ||
131 | setImageIsJpeg(true); | ||
132 | loadJpeg(); | ||
133 | } else { | ||
134 | { | ||
135 | QCopEnvelope( "QPE/System", "busy()" ); | ||
136 | } | ||
137 | setImageIsJpeg(false); | ||
138 | _original_data.load(path); | ||
139 | _original_data.convertDepth(QPixmap::defaultDepth()); | ||
140 | _original_data.setAlphaBuffer(false); | ||
141 | { | ||
142 | QCopEnvelope env( "QPE/System", "notBusy(QString)" ); | ||
143 | env << "Image loaded"; | ||
144 | } | ||
145 | } | ||
146 | _image_data = QImage(); | ||
147 | if (FirstResizeDone()) { | ||
148 | generateImage(); | ||
149 | } | ||
150 | } | ||
151 | |||
152 | /* should be called every time the QImage changed it content */ | ||
153 | void OImageScrollView::init() | ||
154 | { | ||
155 | odebug << "init " << oendl; | ||
156 | |||
157 | /* | ||
158 | * create the zoomer | ||
159 | * and connect ther various signals | ||
160 | */ | ||
161 | _zoomer = new Opie::MM::OImageZoomer( this, "The Zoomer" ); | ||
162 | connect(_zoomer, SIGNAL( zoomAreaRel(int,int)), | ||
163 | this, SLOT(scrollBy(int,int)) ); | ||
164 | connect(_zoomer, SIGNAL( zoomArea(int,int)), | ||
165 | this, SLOT(center(int,int)) ); | ||
166 | connect(this,SIGNAL(contentsMoving(int,int)), | ||
167 | _zoomer, (SLOT(setVisiblePoint(int,int))) ); | ||
168 | connect(this,SIGNAL(imageSizeChanged(const QSize&)), | ||
169 | _zoomer, SLOT(setImageSize(const QSize&)) ); | ||
170 | connect(this,SIGNAL(viewportSizeChanged(const QSize&)), | ||
171 | _zoomer, SLOT(setViewPortSize(const QSize&)) ); | ||
172 | |||
173 | viewport()->setBackgroundColor(white); | ||
174 | setFocusPolicy(QWidget::StrongFocus); | ||
175 | setImageScaledLoaded(false); | ||
176 | setImageIsJpeg(false); | ||
177 | if (FirstResizeDone()) { | ||
178 | m_last_rot = Rotate0; | ||
179 | generateImage(); | ||
180 | } else if (_original_data.size().isValid()) { | ||
181 | if (image_fit_into(_original_data.size()) || !ShowZoomer()) _zoomer->hide(); | ||
182 | resizeContents(_original_data.width(),_original_data.height()); | ||
183 | } | ||
184 | } | ||
185 | |||
186 | void OImageScrollView::setAutoRotate(bool how) | ||
187 | { | ||
188 | /* to avoid double repaints */ | ||
189 | if (AutoRotate() != how) { | ||
190 | m_states.setBit(AUTO_ROTATE,how); | ||
191 | _image_data = QImage(); | ||
192 | generateImage(); | ||
193 | } | ||
194 | } | ||
195 | |||
196 | bool OImageScrollView::AutoRotate()const | ||
197 | { | ||
198 | return m_states.testBit(AUTO_ROTATE); | ||
199 | } | ||
200 | |||
201 | void OImageScrollView::setAutoScale(bool how) | ||
202 | { | ||
203 | m_states.setBit(AUTO_SCALE,how); | ||
204 | if (!how) { | ||
205 | setAutoRotate(false); | ||
206 | } | ||
207 | _image_data = QImage(); | ||
208 | if (ImageIsJpeg() && how == false && ImageScaledLoaded()==true) { | ||
209 | loadJpeg(true); | ||
210 | } | ||
211 | generateImage(); | ||
212 | } | ||
213 | |||
214 | bool OImageScrollView::AutoScale()const | ||
215 | { | ||
216 | return m_states.testBit(AUTO_SCALE); | ||
217 | } | ||
218 | |||
219 | OImageScrollView::~OImageScrollView() | ||
220 | { | ||
221 | } | ||
222 | |||
223 | void OImageScrollView::rescaleImage(int w, int h) | ||
224 | { | ||
225 | if (_image_data.width()==w && _image_data.height()==h) { | ||
226 | return; | ||
227 | } | ||
228 | double hs = (double)h / (double)_image_data.height() ; | ||
229 | double ws = (double)w / (double)_image_data.width() ; | ||
230 | double scaleFactor = (hs > ws) ? ws : hs; | ||
231 | int smoothW = (int)(scaleFactor * _image_data.width()); | ||
232 | int smoothH = (int)(scaleFactor * _image_data.height()); | ||
233 | _image_data = _image_data.smoothScale(smoothW,smoothH); | ||
234 | } | ||
235 | |||
236 | void OImageScrollView::rotate_into_data(Rotation r) | ||
237 | { | ||
238 | /* realy - we must do this that way, 'cause when acting direct on _image_data the app will | ||
239 | segfault :( */ | ||
240 | QImage dest; | ||
241 | int x, y; | ||
242 | if ( _original_data.depth() > 8 ) | ||
243 | { | ||
244 | unsigned int *srcData, *destData; | ||
245 | switch ( r ) | ||
246 | { | ||
247 | case Rotate90: | ||
248 | dest.create(_original_data.height(), _original_data.width(), _original_data.depth()); | ||
249 | for ( y=0; y < _original_data.height(); ++y ) | ||
250 | { | ||
251 | srcData = (unsigned int *)_original_data.scanLine(y); | ||
252 | for ( x=0; x < _original_data.width(); ++x ) | ||
253 | { | ||
254 | destData = (unsigned int *)dest.scanLine(x); | ||
255 | destData[_original_data.height()-y-1] = srcData[x]; | ||
256 | } | ||
257 | } | ||
258 | break; | ||
259 | case Rotate180: | ||
260 | dest.create(_original_data.width(), _original_data.height(), _original_data.depth()); | ||
261 | for ( y=0; y < _original_data.height(); ++y ) | ||
262 | { | ||
263 | srcData = (unsigned int *)_original_data.scanLine(y); | ||
264 | destData = (unsigned int *)dest.scanLine(_original_data.height()-y-1); | ||
265 | for ( x=0; x < _original_data.width(); ++x ) | ||
266 | destData[_original_data.width()-x-1] = srcData[x]; | ||
267 | } | ||
268 | break; | ||
269 | case Rotate270: | ||
270 | dest.create(_original_data.height(), _original_data.width(), _original_data.depth()); | ||
271 | for ( y=0; y < _original_data.height(); ++y ) | ||
272 | { | ||
273 | srcData = (unsigned int *)_original_data.scanLine(y); | ||
274 | for ( x=0; x < _original_data.width(); ++x ) | ||
275 | { | ||
276 | destData = (unsigned int *)dest.scanLine(_original_data.width()-x-1); | ||
277 | destData[y] = srcData[x]; | ||
278 | } | ||
279 | } | ||
280 | break; | ||
281 | default: | ||
282 | dest = _original_data; | ||
283 | break; | ||
284 | } | ||
285 | } | ||
286 | else | ||
287 | { | ||
288 | unsigned char *srcData, *destData; | ||
289 | unsigned int *srcTable, *destTable; | ||
290 | switch ( r ) | ||
291 | { | ||
292 | case Rotate90: | ||
293 | dest.create(_original_data.height(), _original_data.width(), _original_data.depth()); | ||
294 | dest.setNumColors(_original_data.numColors()); | ||
295 | srcTable = (unsigned int *)_original_data.colorTable(); | ||
296 | destTable = (unsigned int *)dest.colorTable(); | ||
297 | for ( x=0; x < _original_data.numColors(); ++x ) | ||
298 | destTable[x] = srcTable[x]; | ||
299 | for ( y=0; y < _original_data.height(); ++y ) | ||
300 | { | ||
301 | srcData = (unsigned char *)_original_data.scanLine(y); | ||
302 | for ( x=0; x < _original_data.width(); ++x ) | ||
303 | { | ||
304 | destData = (unsigned char *)dest.scanLine(x); | ||
305 | destData[_original_data.height()-y-1] = srcData[x]; | ||
306 | } | ||
307 | } | ||
308 | break; | ||
309 | case Rotate180: | ||
310 | dest.create(_original_data.width(), _original_data.height(), _original_data.depth()); | ||
311 | dest.setNumColors(_original_data.numColors()); | ||
312 | srcTable = (unsigned int *)_original_data.colorTable(); | ||
313 | destTable = (unsigned int *)dest.colorTable(); | ||
314 | for ( x=0; x < _original_data.numColors(); ++x ) | ||
315 | destTable[x] = srcTable[x]; | ||
316 | for ( y=0; y < _original_data.height(); ++y ) | ||
317 | { | ||
318 | srcData = (unsigned char *)_original_data.scanLine(y); | ||
319 | destData = (unsigned char *)dest.scanLine(_original_data.height()-y-1); | ||
320 | for ( x=0; x < _original_data.width(); ++x ) | ||
321 | destData[_original_data.width()-x-1] = srcData[x]; | ||
322 | } | ||
323 | break; | ||
324 | case Rotate270: | ||
325 | dest.create(_original_data.height(), _original_data.width(), _original_data.depth()); | ||
326 | dest.setNumColors(_original_data.numColors()); | ||
327 | srcTable = (unsigned int *)_original_data.colorTable(); | ||
328 | destTable = (unsigned int *)dest.colorTable(); | ||
329 | for ( x=0; x < _original_data.numColors(); ++x ) | ||
330 | destTable[x] = srcTable[x]; | ||
331 | for ( y=0; y < _original_data.height(); ++y ) | ||
332 | { | ||
333 | srcData = (unsigned char *)_original_data.scanLine(y); | ||
334 | for ( x=0; x < _original_data.width(); ++x ) | ||
335 | { | ||
336 | destData = (unsigned char *)dest.scanLine(_original_data.width()-x-1); | ||
337 | destData[y] = srcData[x]; | ||
338 | } | ||
339 | } | ||
340 | break; | ||
341 | default: | ||
342 | dest = _original_data; | ||
343 | break; | ||
344 | } | ||
345 | |||
346 | } | ||
347 | _image_data = dest; | ||
348 | } | ||
349 | |||
350 | void OImageScrollView::generateImage() | ||
351 | { | ||
352 | Rotation r = Rotate0; | ||
353 | if (_original_data.isNull()) return; | ||
354 | { | ||
355 | QCopEnvelope( "QPE/System", "busy()" ); | ||
356 | } | ||
357 | if (width()>height()&&_original_data.width()<_original_data.height() || | ||
358 | width()<height()&&_original_data.width()>_original_data.height()) { | ||
359 | if (AutoRotate()) r = Rotate90; | ||
360 | } | ||
361 | |||
362 | odebug << " r = " << r << oendl; | ||
363 | if (AutoScale()) { | ||
364 | if (!_image_data.size().isValid()||width()>_image_data.width()||height()>_image_data.height()) { | ||
365 | odebug << "Rescaling data" << oendl; | ||
366 | if (r==Rotate0) { | ||
367 | _image_data = _original_data; | ||
368 | } else { | ||
369 | rotate_into_data(r); | ||
370 | } | ||
371 | } | ||
372 | rescaleImage(width(),height()); | ||
373 | resizeContents(_image_data.width(),_image_data.height()); | ||
374 | } else if (!FirstResizeDone()||r!=m_last_rot||_image_data.width()==0) { | ||
375 | if (r==Rotate0) { | ||
376 | _image_data = _original_data; | ||
377 | } else { | ||
378 | rotate_into_data(r); | ||
379 | } | ||
380 | m_last_rot = r; | ||
381 | resizeContents(_image_data.width(),_image_data.height()); | ||
382 | } | ||
383 | _pdata.convertFromImage(_image_data); | ||
384 | |||
385 | |||
386 | /* | ||
387 | * update the zoomer | ||
388 | */ | ||
389 | check_zoomer(); | ||
390 | emit imageSizeChanged( _image_data.size() ); | ||
391 | rescaleImage( 128, 128 ); | ||
392 | /* | ||
393 | * move scrollbar | ||
394 | */ | ||
395 | if (_zoomer) { | ||
396 | _zoomer->setGeometry( viewport()->width()-_image_data.width()/2, viewport()->height()-_image_data.height()/2, | ||
397 | _image_data.width()/2, _image_data.height()/2 ); | ||
398 | _zoomer->setImage( _image_data ); | ||
399 | } | ||
400 | /* | ||
401 | * invalidate | ||
402 | */ | ||
403 | _image_data=QImage(); | ||
404 | { | ||
405 | QCopEnvelope env( "QPE/System", "notBusy(QString)" ); | ||
406 | env << "Image generated"; | ||
407 | } | ||
408 | } | ||
409 | |||
410 | void OImageScrollView::resizeEvent(QResizeEvent * e) | ||
411 | { | ||
412 | odebug << "OImageScrollView resizeEvent" << oendl; | ||
413 | QScrollView::resizeEvent(e); | ||
414 | generateImage(); | ||
415 | setFirstResizeDone(true); | ||
416 | emit viewportSizeChanged( viewport()->size() ); | ||
417 | |||
418 | } | ||
419 | |||
420 | void OImageScrollView::keyPressEvent(QKeyEvent * e) | ||
421 | { | ||
422 | if (!e) return; | ||
423 | int dx = horizontalScrollBar()->lineStep(); | ||
424 | int dy = verticalScrollBar()->lineStep(); | ||
425 | if (e->key()==Qt::Key_Right) { | ||
426 | scrollBy(dx,0); | ||
427 | e->accept(); | ||
428 | } else if (e->key()==Qt::Key_Left) { | ||
429 | scrollBy(0-dx,0); | ||
430 | e->accept(); | ||
431 | } else if (e->key()==Qt::Key_Up) { | ||
432 | scrollBy(0,0-dy); | ||
433 | e->accept(); | ||
434 | } else if (e->key()==Qt::Key_Down) { | ||
435 | scrollBy(0,dy); | ||
436 | e->accept(); | ||
437 | } else { | ||
438 | e->ignore(); | ||
439 | } | ||
440 | QScrollView::keyPressEvent(e); | ||
441 | } | ||
442 | |||
443 | void OImageScrollView::drawContents(QPainter * p, int clipx, int clipy, int clipw, int cliph) | ||
444 | { | ||
445 | int w = clipw; | ||
446 | int h = cliph; | ||
447 | int x = clipx; | ||
448 | int y = clipy; | ||
449 | bool erase = false; | ||
450 | |||
451 | if (!_pdata.size().isValid()) { | ||
452 | p->fillRect(clipx,clipy,clipw,cliph,white); | ||
453 | return; | ||
454 | } | ||
455 | if (w>_pdata.width()) { | ||
456 | w=_pdata.width(); | ||
457 | x = 0; | ||
458 | erase = true; | ||
459 | } else if (x+w>_pdata.width()){ | ||
460 | x = _pdata.width()-w; | ||
461 | } | ||
462 | if (h>_pdata.height()) { | ||
463 | h=_pdata.height(); | ||
464 | y = 0; | ||
465 | erase = true; | ||
466 | } else if (y+h>_pdata.height()){ | ||
467 | y = _pdata.height()-h; | ||
468 | } | ||
469 | if (erase||_original_data.hasAlphaBuffer()) { | ||
470 | p->fillRect(clipx,clipy,clipw,cliph,white); | ||
471 | } | ||
472 | p->drawPixmap(clipx,clipy,_pdata,x,y,w,h); | ||
473 | } | ||
474 | |||
475 | /* using the real geometry points and not the translated points is wanted! */ | ||
476 | void OImageScrollView::viewportMouseMoveEvent(QMouseEvent* e) | ||
477 | { | ||
478 | odebug << "Move X and Y " << e->x() << " " << e->y() << oendl; | ||
479 | int mx, my; | ||
480 | mx = e->x(); | ||
481 | my = e->y(); | ||
482 | if (_mouseStartPosX!=-1 && _mouseStartPosY!=-1) { | ||
483 | int diffx = _mouseStartPosX-mx; | ||
484 | int diffy = _mouseStartPosY-my; | ||
485 | #if 0 | ||
486 | QScrollBar*xbar = horizontalScrollBar(); | ||
487 | QScrollBar*ybar = verticalScrollBar(); | ||
488 | if (xbar->value()+diffx>xbar->maxValue()) { | ||
489 | diffx = xbar->maxValue()-xbar->value(); | ||
490 | } else if (xbar->value()+diffx<0) { | ||
491 | diffx=0-xbar->value(); | ||
492 | } | ||
493 | if (ybar->value()+diffy>ybar->maxValue()) { | ||
494 | diffy = ybar->maxValue()-ybar->value(); | ||
495 | } else if (ybar->value()+diffy<0) { | ||
496 | diffy=0-ybar->value(); | ||
497 | } | ||
498 | #endif | ||
499 | scrollBy(diffx,diffy); | ||
500 | } | ||
501 | _mouseStartPosX=mx; | ||
502 | _mouseStartPosY=my; | ||
503 | } | ||
504 | |||
505 | void OImageScrollView::contentsMousePressEvent ( QMouseEvent * e) | ||
506 | { | ||
507 | odebug << " X and Y " << e->x() << " " << e->y() << oendl; | ||
508 | /* this marks the beginning of a possible mouse move. Due internal reasons of QT | ||
509 | the geometry values here may real differ from that set in MoveEvent (I don't know | ||
510 | why). For getting them in real context, we use the first move-event to set the start | ||
511 | position ;) | ||
512 | */ | ||
513 | _mouseStartPosX = -1; | ||
514 | _mouseStartPosY = -1; | ||
515 | } | ||
516 | |||
517 | void OImageScrollView::setDestructiveClose() { | ||
518 | WFlags fl = getWFlags(); | ||
519 | /* clear it just in case */ | ||
520 | fl &= ~WDestructiveClose; | ||
521 | fl |= WDestructiveClose; | ||
522 | setWFlags( fl ); | ||
523 | } | ||
524 | |||
525 | bool OImageScrollView::image_fit_into(const QSize&s ) | ||
526 | { | ||
527 | if (s.width()>width()||s.height()>height()) { | ||
528 | return false; | ||
529 | } | ||
530 | return true; | ||
531 | } | ||
532 | |||
533 | void OImageScrollView::setShowZoomer(bool how) | ||
534 | { | ||
535 | m_states.setBit(SHOW_ZOOMER,how); | ||
536 | check_zoomer(); | ||
537 | } | ||
538 | |||
539 | bool OImageScrollView::ShowZoomer()const | ||
540 | { | ||
541 | return m_states.testBit(SHOW_ZOOMER); | ||
542 | } | ||
543 | |||
544 | void OImageScrollView::check_zoomer() | ||
545 | { | ||
546 | if (!_zoomer) return; | ||
547 | if ( (!ShowZoomer()||image_fit_into(_pdata.size()) ) && _zoomer->isVisible()) { | ||
548 | _zoomer->hide(); | ||
549 | } else if ( ShowZoomer() && !image_fit_into(_pdata.size()) && _zoomer->isHidden()){ | ||
550 | _zoomer->show(); | ||
551 | } | ||
552 | } | ||
553 | |||
554 | bool OImageScrollView::FirstResizeDone()const | ||
555 | { | ||
556 | return m_states.testBit(FIRST_RESIZE_DONE); | ||
557 | } | ||
558 | |||
559 | void OImageScrollView::setFirstResizeDone(bool how) | ||
560 | { | ||
561 | m_states.setBit(FIRST_RESIZE_DONE,how); | ||
562 | } | ||
563 | |||
564 | bool OImageScrollView::ImageIsJpeg()const | ||
565 | { | ||
566 | return m_states.testBit(IMAGE_IS_JPEG); | ||
567 | } | ||
568 | |||
569 | void OImageScrollView::setImageIsJpeg(bool how) | ||
570 | { | ||
571 | m_states.setBit(IMAGE_IS_JPEG,how); | ||
572 | } | ||
573 | |||
574 | bool OImageScrollView::ImageScaledLoaded()const | ||
575 | { | ||
576 | return m_states.testBit(IMAGE_SCALED_LOADED); | ||
577 | } | ||
578 | |||
579 | void OImageScrollView::setImageScaledLoaded(bool how) | ||
580 | { | ||
581 | m_states.setBit(IMAGE_SCALED_LOADED,how); | ||
582 | } | ||
583 | |||
584 | } // namespace MM | ||
585 | } // namespace Opie | ||