summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (show whitespace changes)
-rw-r--r--libopie2/opiemm/oimagescrollview.cpp5
-rw-r--r--noncore/graphics/opie-eye/gui/imageview.cpp5
-rw-r--r--noncore/graphics/opie-eye/gui/mainwindow.cpp13
3 files changed, 15 insertions, 8 deletions
diff --git a/libopie2/opiemm/oimagescrollview.cpp b/libopie2/opiemm/oimagescrollview.cpp
index 10da823..76f50e1 100644
--- a/libopie2/opiemm/oimagescrollview.cpp
+++ b/libopie2/opiemm/oimagescrollview.cpp
@@ -1,674 +1,677 @@
#include "oimagescrollview.h"
#include <opie2/oimagezoomer.h>
#include <opie2/odebug.h>
#include <opie2/oapplication.h>
#include <opie2/owait.h>
#include <opie2/opieexif.h>
#include <qimage.h>
#include <qlayout.h>
/* for usage with the bitset */
#define AUTO_SCALE 0
#define AUTO_ROTATE 1
#define SHOW_ZOOMER 2
#define FIRST_RESIZE_DONE 3
#define IMAGE_IS_JPEG 4
#define IMAGE_SCALED_LOADED 5
#define SCROLLVIEW_BITSET_SIZE 6
namespace Opie {
namespace MM {
OImageScrollView::OImageScrollView( QWidget* parent, const char* name, WFlags f )
:QScrollView(parent,name,f|Qt::WRepaintNoErase ),_image_data(),_original_data(),
m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("")
{
_zoomer = 0;
m_states[AUTO_SCALE]=true;
m_states[AUTO_ROTATE]=true;
m_states[FIRST_RESIZE_DONE]=false;
m_states[IMAGE_IS_JPEG]=false;
m_states[IMAGE_SCALED_LOADED]=false;
m_states[SHOW_ZOOMER]=true;
_newImage = true;
init();
}
OImageScrollView::OImageScrollView (const QImage&img, QWidget * parent, const char * name, WFlags f,bool always_scale,bool rfit)
:QScrollView(parent,name,f|Qt::WRepaintNoErase),_image_data(),_original_data(img),
m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("")
{
_zoomer = 0;
m_states[AUTO_SCALE]=always_scale;
m_states[AUTO_ROTATE]=rfit;
m_states[FIRST_RESIZE_DONE]=false;
m_states[IMAGE_IS_JPEG]=false;
m_states[IMAGE_SCALED_LOADED]=false;
m_states[SHOW_ZOOMER]=true;
_original_data.convertDepth(QPixmap::defaultDepth());
_original_data.setAlphaBuffer(false);
_newImage = true;
init();
}
OImageScrollView::OImageScrollView (const QString&img, QWidget * parent, const char * name, WFlags f,bool always_scale,bool rfit)
:QScrollView(parent,name,f|Qt::WRepaintNoErase),_image_data(),_original_data(),m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("")
{
_zoomer = 0;
m_states.resize(SCROLLVIEW_BITSET_SIZE);
m_states[AUTO_SCALE]=always_scale;
m_states[AUTO_ROTATE]=rfit;
m_states[FIRST_RESIZE_DONE]=false;
m_states[IMAGE_IS_JPEG]=false;
m_states[IMAGE_SCALED_LOADED]=false;
m_states[SHOW_ZOOMER]=true;
_newImage = true;
init();
setImage(img);
}
void OImageScrollView::setImage(const QImage&img)
{
_image_data = QImage();
_original_data=img;
_original_data.convertDepth(QPixmap::defaultDepth());
_original_data.setAlphaBuffer(false);
m_lastName = "";
setImageIsJpeg(false);
setImageScaledLoaded(false);
_newImage = true;
if (FirstResizeDone()) {
generateImage();
}
}
void OImageScrollView::loadJpeg(bool interncall)
{
if (m_lastName.isEmpty()) return;
QImageIO iio( m_lastName, 0l );
QString param;
bool real_load = false;
_newImage = true;
if (AutoScale()) {
if (!interncall) {
ExifData xf;
bool scanned = xf.scan(m_lastName);
int wid, hei;
wid = QApplication::desktop()->width();
hei = QApplication::desktop()->height();
if (hei>wid) {
wid = hei;
} else {
hei = wid;
}
if ( (scanned && (wid<xf.getWidth()||hei<xf.getHeight()))||!scanned ) {
param = QString( "Fast Shrink( 3 ) Scale( %1, %2, ScaleMin)" ).arg( wid ).arg( hei );
iio.setParameters(param.latin1());
setImageScaledLoaded(true);
}
real_load = true;
}
} else {
if (ImageScaledLoaded()||!interncall) {
real_load = true;
}
setImageScaledLoaded(false);
}
if (real_load) {
_original_data = iio.read() ? iio.image() : QImage();
}
}
void OImageScrollView::setImage( const QString& path ) {
if (m_lastName == path) return;
m_lastName = path;
_newImage = true;
_original_data = QImage();
QString itype = QImage::imageFormat(m_lastName);
if (itype == "JPEG") {
setImageIsJpeg(true);
loadJpeg();
} else {
setImageIsJpeg(false);
_original_data.load(path);
_original_data.convertDepth(QPixmap::defaultDepth());
_original_data.setAlphaBuffer(false);
}
_image_data = QImage();
if (FirstResizeDone()) {
generateImage();
if (isVisible()) viewport()->repaint(true);
}
}
/* should be called every time the QImage changed it content */
void OImageScrollView::init()
{
/*
* create the zoomer
* and connect ther various signals
*/
_zoomer = new Opie::MM::OImageZoomer( this, "The Zoomer" );
connect(_zoomer, SIGNAL( zoomAreaRel(int,int)),
this, SLOT(scrollBy(int,int)) );
connect(_zoomer, SIGNAL( zoomArea(int,int)),
this, SLOT(center(int,int)) );
connect(this,SIGNAL(contentsMoving(int,int)),
_zoomer, (SLOT(setVisiblePoint(int,int))) );
connect(this,SIGNAL(imageSizeChanged(const QSize&)),
_zoomer, SLOT(setImageSize(const QSize&)) );
connect(this,SIGNAL(viewportSizeChanged(const QSize&)),
_zoomer, SLOT(setViewPortSize(const QSize&)) );
setBackgroundColor(white);
setFocusPolicy(QWidget::StrongFocus);
setImageScaledLoaded(false);
setImageIsJpeg(false);
if (FirstResizeDone()) {
m_last_rot = Rotate0;
generateImage();
} else if (_original_data.size().isValid()) {
if (image_fit_into(_original_data.size()) || !ShowZoomer()) _zoomer->hide();
resizeContents(_original_data.width(),_original_data.height());
}
_intensity = 0;
}
void OImageScrollView::setAutoRotate(bool how)
{
/* to avoid double repaints */
if (AutoRotate() != how) {
m_states.setBit(AUTO_ROTATE,how);
_image_data = QImage();
generateImage();
}
}
bool OImageScrollView::AutoRotate()const
{
return m_states.testBit(AUTO_ROTATE);
}
void OImageScrollView::setAutoScaleRotate(bool scale, bool rotate)
{
m_states.setBit(AUTO_ROTATE,rotate);
setAutoScale(scale);
}
void OImageScrollView::setAutoScale(bool how)
{
m_states.setBit(AUTO_SCALE,how);
_image_data = QImage();
if (ImageIsJpeg() && how == false && ImageScaledLoaded()==true) {
loadJpeg(true);
}
+ _newImage = true;
generateImage();
}
bool OImageScrollView::AutoScale()const
{
return m_states.testBit(AUTO_SCALE);
}
OImageScrollView::~OImageScrollView()
{
}
void OImageScrollView::rescaleImage(int w, int h)
{
if (_image_data.width()==w && _image_data.height()==h) {
return;
}
double hs = (double)h / (double)_image_data.height() ;
double ws = (double)w / (double)_image_data.width() ;
double scaleFactor = (hs > ws) ? ws : hs;
int smoothW = (int)(scaleFactor * _image_data.width());
int smoothH = (int)(scaleFactor * _image_data.height());
_image_data = _image_data.smoothScale(smoothW,smoothH);
}
void OImageScrollView::rotate_into_data(Rotation r)
{
/* realy - we must do this that way, 'cause when acting direct on _image_data the app will
segfault :( */
QImage dest;
int x, y;
if ( _original_data.depth() > 8 )
{
unsigned int *srcData, *destData;
switch ( r )
{
case Rotate90:
dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
for ( y=0; y < _original_data.height(); ++y )
{
srcData = (unsigned int *)_original_data.scanLine(y);
for ( x=0; x < _original_data.width(); ++x )
{
destData = (unsigned int *)dest.scanLine(x);
destData[_original_data.height()-y-1] = srcData[x];
}
}
break;
case Rotate180:
dest.create(_original_data.width(), _original_data.height(), _original_data.depth());
for ( y=0; y < _original_data.height(); ++y )
{
srcData = (unsigned int *)_original_data.scanLine(y);
destData = (unsigned int *)dest.scanLine(_original_data.height()-y-1);
for ( x=0; x < _original_data.width(); ++x )
destData[_original_data.width()-x-1] = srcData[x];
}
break;
case Rotate270:
dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
for ( y=0; y < _original_data.height(); ++y )
{
srcData = (unsigned int *)_original_data.scanLine(y);
for ( x=0; x < _original_data.width(); ++x )
{
destData = (unsigned int *)dest.scanLine(_original_data.width()-x-1);
destData[y] = srcData[x];
}
}
break;
default:
dest = _original_data;
break;
}
}
else
{
unsigned char *srcData, *destData;
unsigned int *srcTable, *destTable;
switch ( r )
{
case Rotate90:
dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
dest.setNumColors(_original_data.numColors());
srcTable = (unsigned int *)_original_data.colorTable();
destTable = (unsigned int *)dest.colorTable();
for ( x=0; x < _original_data.numColors(); ++x )
destTable[x] = srcTable[x];
for ( y=0; y < _original_data.height(); ++y )
{
srcData = (unsigned char *)_original_data.scanLine(y);
for ( x=0; x < _original_data.width(); ++x )
{
destData = (unsigned char *)dest.scanLine(x);
destData[_original_data.height()-y-1] = srcData[x];
}
}
break;
case Rotate180:
dest.create(_original_data.width(), _original_data.height(), _original_data.depth());
dest.setNumColors(_original_data.numColors());
srcTable = (unsigned int *)_original_data.colorTable();
destTable = (unsigned int *)dest.colorTable();
for ( x=0; x < _original_data.numColors(); ++x )
destTable[x] = srcTable[x];
for ( y=0; y < _original_data.height(); ++y )
{
srcData = (unsigned char *)_original_data.scanLine(y);
destData = (unsigned char *)dest.scanLine(_original_data.height()-y-1);
for ( x=0; x < _original_data.width(); ++x )
destData[_original_data.width()-x-1] = srcData[x];
}
break;
case Rotate270:
dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
dest.setNumColors(_original_data.numColors());
srcTable = (unsigned int *)_original_data.colorTable();
destTable = (unsigned int *)dest.colorTable();
for ( x=0; x < _original_data.numColors(); ++x )
destTable[x] = srcTable[x];
for ( y=0; y < _original_data.height(); ++y )
{
srcData = (unsigned char *)_original_data.scanLine(y);
for ( x=0; x < _original_data.width(); ++x )
{
destData = (unsigned char *)dest.scanLine(_original_data.width()-x-1);
destData[y] = srcData[x];
}
}
break;
default:
dest = _original_data;
break;
}
}
_newImage = true;
_image_data = dest;
}
// yes - sorry - it is NOT gamma it is just BRIGHTNESS. Alwin
void OImageScrollView::apply_gamma(int aValue)
{
- if (!_image_data.size().isValid()) return;
+ if (aValue==0 || !_image_data.size().isValid()) return;
float percent = ((float)aValue/100.0);
+ /* make sure working on a copy */
+ _image_data.detach();
int segColors = _image_data.depth() > 8 ? 256 : _image_data.numColors();
/* must be - otherwise it displays some ... strange colors */
if (segColors<256) segColors=256;
unsigned char *segTbl = new unsigned char[segColors];
int pixels = _image_data.depth()>8?_image_data.width()*_image_data.height() : _image_data.numColors();
bool brighten = (percent >= 0);
if ( percent < 0 ) {
percent = -percent;
}
unsigned int *data = _image_data.depth() > 8 ? (unsigned int *)_image_data.bits() :
(unsigned int *)_image_data.colorTable();
int tmp = 0;
if (brighten) {
for ( int i=0; i < segColors; ++i )
{
tmp = (int)(i*percent);
if ( tmp > 255 )
tmp = 255;
segTbl[i] = tmp;
}
} else {
for ( int i=0; i < segColors; ++i )
{
tmp = (int)(i*percent);
if ( tmp < 0 )
tmp = 0;
segTbl[i] = tmp;
}
}
if (brighten) {
for ( int i=0; i < pixels; ++i )
{
int r = qRed(data[i]);
int g = qGreen(data[i]);
int b = qBlue(data[i]);
int a = qAlpha(data[i]);
r = r + segTbl[r] > 255 ? 255 : r + segTbl[r];
g = g + segTbl[g] > 255 ? 255 : g + segTbl[g];
b = b + segTbl[b] > 255 ? 255 : b + segTbl[b];
data[i] = qRgba(r, g, b,a);
}
} else {
for ( int i=0; i < pixels; ++i )
{
int r = qRed(data[i]);
int g = qGreen(data[i]);
int b = qBlue(data[i]);
int a = qAlpha(data[i]);
r = r - segTbl[r] < 0 ? 0 : r - segTbl[r];
g = g - segTbl[g] < 0 ? 0 : g - segTbl[g];
b = b - segTbl[b] < 0 ? 0 : b - segTbl[b];
data[i] = qRgba(r, g, b, a);
}
}
delete [] segTbl;
}
const int OImageScrollView::Intensity()const
{
return _intensity;
}
int OImageScrollView::setIntensity(int value,bool reload)
{
int oldi = _intensity;
_intensity = value;
if (!_pdata.size().isValid()) {
return _intensity;
}
if (!reload) {
_image_data = _pdata.convertToImage();
apply_gamma(_intensity-oldi);
_pdata.convertFromImage(_image_data);
/*
* invalidate
*/
_image_data=QImage();
if (isVisible()) {
updateContents(contentsX(),contentsY(),width(),height());
}
} else {
_newImage = true;
generateImage();
}
return _intensity;
}
void OImageScrollView::generateImage()
{
Rotation r = Rotate0;
_pdata = QPixmap();
if (_original_data.isNull()) {
emit imageSizeChanged( _image_data.size() );
if (_zoomer) _zoomer->setImage( _image_data );
return;
}
if (width()>height()&&_original_data.width()<_original_data.height() ||
width()<height()&&_original_data.width()>_original_data.height()) {
if (AutoRotate()) r = Rotate90;
}
int twidth,theight;
if (AutoScale() && (_original_data.width()>width() || _original_data.height() > height()) ) {
if (!_image_data.size().isValid()||width()>_image_data.width()||height()>_image_data.height()) {
if (r==Rotate0) {
_image_data = _original_data;
} else {
rotate_into_data(r);
}
_newImage = true;
}
rescaleImage(width(),height());
} else if (!FirstResizeDone()||r!=m_last_rot||_image_data.width()==0) {
if (r==Rotate0) {
_image_data = _original_data;
} else {
rotate_into_data(r);
}
m_last_rot = r;
}
if (_newImage) {
apply_gamma(_intensity);
_newImage = false;
}
_pdata.convertFromImage(_image_data);
twidth = _image_data.width();
theight = _image_data.height();
/*
* update the zoomer
*/
check_zoomer();
emit imageSizeChanged( _image_data.size() );
rescaleImage( 128, 128 );
resizeContents(twidth,theight);
/*
* move scrollbar
*/
if (_zoomer) {
_zoomer->setGeometry( viewport()->width()-_image_data.width()/2, viewport()->height()-_image_data.height()/2,
_image_data.width()/2, _image_data.height()/2 );
_zoomer->setImage( _image_data );
}
/*
* invalidate
*/
_image_data=QImage();
if (isVisible()) {
updateContents(contentsX(),contentsY(),width(),height());
}
}
void OImageScrollView::resizeEvent(QResizeEvent * e)
{
QScrollView::resizeEvent(e);
if (e->oldSize()==e->size()||!isUpdatesEnabled ()) return;
generateImage();
setFirstResizeDone(true);
emit viewportSizeChanged( viewport()->size() );
}
void OImageScrollView::keyPressEvent(QKeyEvent * e)
{
if (!e) return;
int dx = horizontalScrollBar()->lineStep();
int dy = verticalScrollBar()->lineStep();
if (e->key()==Qt::Key_Right) {
scrollBy(dx,0);
e->accept();
} else if (e->key()==Qt::Key_Left) {
scrollBy(0-dx,0);
e->accept();
} else if (e->key()==Qt::Key_Up) {
scrollBy(0,0-dy);
e->accept();
} else if (e->key()==Qt::Key_Down) {
scrollBy(0,dy);
e->accept();
} else {
e->ignore();
}
QScrollView::keyPressEvent(e);
}
void OImageScrollView::drawContents(QPainter * p, int clipx, int clipy, int clipw, int cliph)
{
if (!_pdata.size().isValid()) {
p->fillRect(clipx,clipy,clipw,cliph, backgroundColor());
return;
}
int w = clipw;
int h = cliph;
int x = clipx;
int y = clipy;
bool erase = false;
if (w>_pdata.width()) {
w = _pdata.width()-x;
erase=true;
}
if (h>_pdata.height()) {
h = _pdata.height()-y;
erase=true;
}
if (!erase && (clipy+cliph>_pdata.height()||clipx+clipw>_pdata.width())) {
erase = true;
}
if (erase||_original_data.hasAlphaBuffer()) {
p->fillRect(clipx,clipy,clipw,cliph, backgroundColor());
}
if (w>0 && h>0&&x<_pdata.width()&&y<_pdata.height()) {
p->drawPixmap(clipx,clipy,_pdata,x,y,w,h);
}
}
/* using the real geometry points and not the translated points is wanted! */
void OImageScrollView::viewportMouseMoveEvent(QMouseEvent* e)
{
int mx, my;
mx = e->x();
my = e->y();
if (_mouseStartPosX!=-1 && _mouseStartPosY!=-1) {
int diffx = _mouseStartPosX-mx;
int diffy = _mouseStartPosY-my;
scrollBy(diffx,diffy);
}
_mouseStartPosX=mx;
_mouseStartPosY=my;
}
void OImageScrollView::contentsMousePressEvent ( QMouseEvent * e)
{
/* this marks the beginning of a possible mouse move. Due internal reasons of QT
the geometry values here may real differ from that set in MoveEvent (I don't know
why). For getting them in real context, we use the first move-event to set the start
position ;)
*/
_mouseStartPosX = -1;
_mouseStartPosY = -1;
}
void OImageScrollView::setDestructiveClose() {
WFlags fl = getWFlags();
/* clear it just in case */
fl &= ~WDestructiveClose;
fl |= WDestructiveClose;
setWFlags( fl );
}
bool OImageScrollView::image_fit_into(const QSize&s )
{
if (s.width()>width()||s.height()>height()) {
return false;
}
return true;
}
void OImageScrollView::setShowZoomer(bool how)
{
m_states.setBit(SHOW_ZOOMER,how);
check_zoomer();
}
bool OImageScrollView::ShowZoomer()const
{
return m_states.testBit(SHOW_ZOOMER);
}
void OImageScrollView::check_zoomer()
{
if (!_zoomer) return;
if ( (!ShowZoomer()||image_fit_into(_pdata.size()) ) && _zoomer->isVisible()) {
_zoomer->hide();
} else if ( ShowZoomer() && !image_fit_into(_pdata.size()) && _zoomer->isHidden()){
_zoomer->show();
}
}
bool OImageScrollView::FirstResizeDone()const
{
return m_states.testBit(FIRST_RESIZE_DONE);
}
void OImageScrollView::setFirstResizeDone(bool how)
{
m_states.setBit(FIRST_RESIZE_DONE,how);
}
bool OImageScrollView::ImageIsJpeg()const
{
return m_states.testBit(IMAGE_IS_JPEG);
}
void OImageScrollView::setImageIsJpeg(bool how)
{
m_states.setBit(IMAGE_IS_JPEG,how);
}
bool OImageScrollView::ImageScaledLoaded()const
{
return m_states.testBit(IMAGE_SCALED_LOADED);
}
void OImageScrollView::setImageScaledLoaded(bool how)
{
m_states.setBit(IMAGE_SCALED_LOADED,how);
}
} // namespace MM
} // namespace Opie
diff --git a/noncore/graphics/opie-eye/gui/imageview.cpp b/noncore/graphics/opie-eye/gui/imageview.cpp
index 994fe12..b919ca8 100644
--- a/noncore/graphics/opie-eye/gui/imageview.cpp
+++ b/noncore/graphics/opie-eye/gui/imageview.cpp
@@ -1,321 +1,318 @@
#include "imageview.h"
#include <opie2/odebug.h>
#include <opie2/oconfig.h>
#include <opie2/okeyconfigwidget.h>
#include <qpe/resource.h>
#include <qpe/qpeapplication.h>
#include <qpe/qcopenvelope_qws.h>
#include <qpopupmenu.h>
#include <qtimer.h>
#include <qaction.h>
using namespace Opie::Core;
ImageView::ImageView(Opie::Core::OConfig *cfg, QWidget* parent, const char* name, WFlags fl )
: Opie::MM::OImageScrollView(parent,name,fl)
{
m_viewManager = 0;
focus_in_count = 0;
m_cfg = cfg;
m_isFullScreen = false;
m_ignore_next_in = false;
m_slideTimer = 0;
QPEApplication::setStylusOperation(viewport(),QPEApplication::RightOnHold);
initKeys();
m_slideValue = 5;
m_gDisplayType = 0;
m_gPrevNext = 0;
m_hGroup = 0;
m_gBright = 0;
m_Rotated = false;
closeIfHide = false;
int min = QApplication::desktop()->size().width()>QApplication::desktop()->size().height()?
QApplication::desktop()->size().height():QApplication::desktop()->size().width();
if (min>320) {
// bigscreen
setMinimumSize(min/3,min/3);
} else {
setMinimumSize(10,10);
}
connect(this,SIGNAL(incBrightness()),this,SLOT(slotIncBrightness()));
connect(this,SIGNAL(decBrightness()),this,SLOT(slotDecBrightness()));
m_sysChannel = new QCopChannel( "QPE/System", this );
connect( m_sysChannel, SIGNAL( received(const QCString&,const QByteArray&) ),
this, SLOT( systemMessage(const QCString&,const QByteArray&) ) );
+ setKeyCompression(true);
}
void ImageView::slotIncBrightness()
{
int lb = Intensity()+5;
if (lb>100) lb=100;
setIntensity(lb,true);
}
void ImageView::slotDecBrightness()
{
int lb = Intensity()-5;
if (lb<-100) lb=-100;
setIntensity(lb,true);
}
void ImageView::systemMessage( const QCString& msg, const QByteArray& data )
{
int _newrotation;
QDataStream stream( data, IO_ReadOnly );
- odebug << "received system message: " << msg << oendl;
if ( msg == "setCurrentRotation(int)" )
{
stream >> _newrotation;
- odebug << "received setCurrentRotation(" << _newrotation << ")" << oendl;
if (!fullScreen()) {
m_rotation = _newrotation;
return;
}
}
}
void ImageView::setMenuActions(QActionGroup*hGroup,QActionGroup*nextprevGroup, QActionGroup*disptypeGroup,QActionGroup*brightGroup)
{
m_gDisplayType = disptypeGroup;
m_gPrevNext = nextprevGroup;
m_hGroup = hGroup;
m_gBright = brightGroup;
}
ImageView::~ImageView()
{
odebug << "Destructor imageview" << oendl;
delete m_viewManager;
}
Opie::Core::OKeyConfigManager* ImageView::manager()
{
if (!m_viewManager) {
initKeys();
}
return m_viewManager;
}
void ImageView::startSlide(int value)
{
if (!m_slideTimer) {
m_slideTimer = new QTimer(this);
}
m_slideValue=value;
connect(m_slideTimer,SIGNAL(timeout()),SLOT(nextSlide()));
/* this "+1" is one millisecond. with that we can setup a slideshowvalue
of 0. eg "as fast as possible".
*/
m_slideTimer->start(m_slideValue*1000+1,true);
}
void ImageView::stopSlide()
{
if (!m_slideTimer) {
return;
}
m_slideTimer->stop();
delete m_slideTimer;
m_slideTimer = 0;
}
void ImageView::nextSlide()
{
if (!m_slideTimer) {
return;
}
#if 0
if (isHidden()) {
delete m_slideTimer;
m_slideTimer = 0;
return;
}
#endif
emit dispNext();
m_slideTimer->start(m_slideValue*1000,true);
}
void ImageView::initKeys()
{
odebug << "init imageview keys" << oendl;
if (!m_cfg) {
m_cfg = new Opie::Core::OConfig("opie-eye");
m_cfg->setGroup("image_view_keys" );
}
Opie::Core::OKeyPair::List lst;
lst.append( Opie::Core::OKeyPair::upArrowKey() );
lst.append( Opie::Core::OKeyPair::downArrowKey() );
lst.append( Opie::Core::OKeyPair::leftArrowKey() );
lst.append( Opie::Core::OKeyPair::rightArrowKey() );
lst.append( Opie::Core::OKeyPair(Qt::Key_Escape,0));
m_viewManager = new Opie::Core::OKeyConfigManager(m_cfg, "image_view_keys",
lst, false,this, "image_view_keys" );
/**
* Handle KeyEvents when they're pressed. This avoids problems
* with 'double next' on Return.
* The Return press would switch to this view and the return
* release would emit the dispNext Signal.
*/
m_viewManager->setEventMask( Opie::Core::OKeyConfigManager::MaskPressed );
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("View Image Info"), "imageviewinfo",
Resource::loadPixmap("1to1"), ViewInfo,
Opie::Core::OKeyPair(Qt::Key_I,0),
this, SLOT(slotShowImageInfo())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Toggle autorotate"), "imageautorotate",
Resource::loadPixmap("rotate"), Autorotate,
Opie::Core::OKeyPair(Qt::Key_R,0),
this, SIGNAL(toggleAutorotate())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Toggle autoscale"), "imageautoscale",
Resource::loadPixmap("1to1"), Autoscale,
Opie::Core::OKeyPair(Qt::Key_S,0),
this, SIGNAL(toggleAutoscale())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Switch to next image"), "imageshownext",
Resource::loadPixmap("forward"), ShowNext,
Opie::Core::OKeyPair(Qt::Key_Return,0),
this, SIGNAL(dispNext())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Switch to previous image"), "imageshowprev",
Resource::loadPixmap("back"), ShowPrevious,
Opie::Core::OKeyPair(Qt::Key_P,0),
this, SIGNAL(dispPrev())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Toggle fullscreen"), "imagefullscreen",
Resource::loadPixmap("fullscreen"), FullScreen,
Opie::Core::OKeyPair(Qt::Key_F,0),
this, SIGNAL(toggleFullScreen())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Toggle thumbnail"), "imagezoomer",
Resource::loadPixmap("mag"), Zoomer,
Opie::Core::OKeyPair(Qt::Key_T,0),
this, SIGNAL(toggleZoomer())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Increase brightness"), "incbrightness",
Resource::loadPixmap("up"), Incbrightness,
Opie::Core::OKeyPair(Qt::Key_B,0),
this, SIGNAL(incBrightness())));
m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("Decrease brightness"), "decbrightness",
Resource::loadPixmap("down"), Decbrightness,
Opie::Core::OKeyPair(Qt::Key_D,0),
this, SIGNAL(decBrightness())));
m_viewManager->handleWidget( this );
m_viewManager->load();
}
void ImageView::keyReleaseEvent(QKeyEvent * e)
{
if (!e || e->state()!=0) {
return;
}
if (e->key()==Qt::Key_Escape) {
if (fullScreen()) {
emit hideMe();
}
if (closeIfHide) {
QTimer::singleShot(0, qApp, SLOT(closeAllWindows()));
}
}
}
void ImageView::setCloseIfHide(bool how)
{
closeIfHide = how;
}
void ImageView::slotShowImageInfo()
{
emit dispImageInfo(m_lastName);
}
void ImageView::contentsMousePressEvent ( QMouseEvent * e)
{
if (e->button()==1) {
return OImageScrollView::contentsMousePressEvent(e);
}
- odebug << "Popup " << oendl;
QPopupMenu *m = new QPopupMenu(this);
if (!m) return;
if (m_hGroup) {
m_hGroup->addTo(m);
}
if (fullScreen()) {
if (m_gPrevNext) {
m->insertSeparator();
m_gPrevNext->addTo(m);
}
if (m_gDisplayType) {
m->insertSeparator();
m_gDisplayType->addTo(m);
}
if (m_gBright) {
m->insertSeparator();
m_gBright->addTo(m);
}
}
m->setFocus();
m->exec( QPoint( QCursor::pos().x(), QCursor::pos().y()) );
if (m_hGroup) {
m_hGroup->removeFrom(m);
}
if (m_gPrevNext) {
m_gPrevNext->removeFrom(m);
}
if (m_gDisplayType) {
m_gDisplayType->removeFrom(m);
}
if (m_gBright) {
m_gBright->removeFrom(m);
}
delete m;
}
void ImageView::setFullScreen(bool how,bool force)
{
m_isFullScreen = how;
if (how) {
m_ignore_next_in = true;
// setFixedSize(qApp->desktop()->size());
setGeometry(0,0,qApp->desktop()->size().width(),qApp->desktop()->size().height());
if (force) showFullScreen();
} else {
// setMinimumSize(10,10);
}
}
void ImageView::focusInEvent(QFocusEvent *)
{
// Always do it here, no matter the size.
- odebug << "Focus in (view)" << oendl;
//if (fullScreen()) parentWidget()->showNormal();
if (m_ignore_next_in){m_ignore_next_in=false;return;}
if (fullScreen()) enableFullscreen();
}
void ImageView::hide()
{
if (fullScreen()) {
m_ignore_next_in = true;
showNormal();
}
QWidget::hide();
}
void ImageView::enableFullscreen()
{
if (!fullScreen()) return;
if (m_ignore_next_in) {m_ignore_next_in = false;return;}
setUpdatesEnabled(false);
// This is needed because showNormal() forcefully changes the window
// style to WSTyle_TopLevel.
reparent(0, WStyle_Customize | WStyle_NoBorderEx, QPoint(0,0));
// Enable fullscreen.
/* this is the trick - I don't now why, but after a showFullScreen QTE toggles the focus
* so we must block it here! */
m_ignore_next_in = true;
showFullScreen();
setUpdatesEnabled(true);
}
diff --git a/noncore/graphics/opie-eye/gui/mainwindow.cpp b/noncore/graphics/opie-eye/gui/mainwindow.cpp
index 4ee252f..3efbb53 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.cpp
+++ b/noncore/graphics/opie-eye/gui/mainwindow.cpp
@@ -1,833 +1,840 @@
/*
* GPLv2 zecke@handhelds.org
* No WArranty...
*/
#include "mainwindow.h"
#include "imageview.h"
#include "iconview.h"
#include "filesystem.h"
#include "imageinfoui.h"
#include "viewmodebutton.h"
#include "basesetup.h"
#include <iface/ifaceinfo.h>
#include <iface/dirview.h>
#include <opie2/odebug.h>
#include <opie2/owidgetstack.h>
#include <opie2/oapplicationfactory.h>
#include <opie2/otabwidget.h>
#include <opie2/okeyconfigwidget.h>
#include <opie2/owait.h>
#include <opie2/oapplication.h>
#include <qpe/resource.h>
#include <qpe/config.h>
#include <qpe/ir.h>
#include <qpe/storage.h>
#include <qpe/applnk.h>
#include <qtoolbar.h>
#include <qtoolbutton.h>
#include <qlayout.h>
#include <qdialog.h>
#include <qmap.h>
#include <qtimer.h>
#include <qframe.h>
#include <qmenubar.h>
#include <qaction.h>
#include <qspinbox.h>
//OPIE_EXPORT_APP_V2( Opie::Core::OApplicationFactory<PMainWindow>,"Opie Eye" )
OPIE_EXPORT_APP( Opie::Core::OApplicationFactory<PMainWindow>)
PMainWindow::PMainWindow(QWidget* wid, const char* name, WFlags style)
: QMainWindow( wid, name, style ), m_info( 0 ), m_disp( 0 )
{
setCaption( QObject::tr("Opie Eye" ) );
m_cfg = new Opie::Core::OConfig("opie-eye");
m_cfg->setGroup("main" );
readConfig();
m_setDocCalled = false;
m_polishDone = false;
m_SmallWindow = QApplication::desktop()->size().width()<330;
m_storage = new StorageInfo();
connect(m_storage, SIGNAL(disksChanged() ),
this, SLOT( dirChanged() ) );
m_stack = new Opie::Ui::OWidgetStack( this );
setCentralWidget( m_stack );
m_view = new PIconView( m_stack, m_cfg );
m_stack->addWidget( m_view, IconView );
m_stack->raiseWidget( IconView );
connect(m_view, SIGNAL(sig_display(const QString&)),
this, SLOT(slotDisplay(const QString&)));
connect(m_view, SIGNAL(sig_showInfo(const QString&)),
this, SLOT(slotShowInfo(const QString&)) );
connect(this,SIGNAL(changeListMode(int)),m_view,SLOT(slotChangeMode(int)));
listviewMenu = 0;
/* setup menu and toolbar */
setupActions();
setupToolbar();
setupMenu();
m_aHideToolbar->setOn(m_cfg->readBoolEntry("showtoolbar",true));
m_aAutoRotate->setEnabled(!m_aUnscaled->isOn());
if (m_aForceSmall) {
m_aForceSmall->setOn(m_cfg->readBoolEntry("dontshowseperate",true));
}
odebug << "mainwindow constructor done" << oendl;
}
PMainWindow::~PMainWindow() {
}
void PMainWindow::slotToggleZoomer()
{
m_aZoomer->setOn(!m_aZoomer->isOn());
}
void PMainWindow::slotZoomerToggled(bool how)
{
if (m_disp) {
m_disp->setShowZoomer(how);
}
if (autoSave) {
m_cfg->writeEntry("zoomeron",how);
}
}
void PMainWindow::slotToggleAutorotate()
{
if (!m_aAutoRotate->isEnabled()) return;
m_aAutoRotate->setOn(!m_aAutoRotate->isOn());
}
void PMainWindow::slotToggleAutoscale()
{
m_aUnscaled->setOn(!m_aUnscaled->isOn());
}
void PMainWindow::slotRotateToggled(bool how)
{
if (autoSave) {
m_cfg->writeEntry("autorotate",how);
}
if (m_disp) {
m_disp->setAutoScaleRotate(!m_aUnscaled->isOn(),how);
}
}
void PMainWindow::slotScaleToggled(bool how)
{
if (autoSave) {
m_cfg->writeEntry("unscaled",how);
}
odebug << "Unscaled: " << m_aUnscaled->isOn() << oendl;
odebug << "How: " << how << oendl;
if (how) {
m_aAutoRotate->setOn(false);
}
if (m_disp) {
m_disp->setAutoScaleRotate(!m_aUnscaled->isOn(),m_aAutoRotate->isOn());
}
m_aAutoRotate->setEnabled(!how);
odebug << "Autorotate: " << m_aAutoRotate->isOn() << oendl;
}
void PMainWindow::slotConfig() {
/*
* have a tab with the possible views
* a tab for globals image cache size.. scaled loading
* and one tab for the KeyConfigs
*/
QDialog dlg(this, 0, true);
dlg.setCaption( tr("Opie Eye - Config" ) );
QHBoxLayout *lay = new QHBoxLayout(&dlg);
Opie::Ui::OTabWidget *wid = new Opie::Ui::OTabWidget(&dlg );
lay->addWidget( wid );
BaseSetup*bSetup = new BaseSetup(m_cfg,wid);
wid->addTab(bSetup,"SettingsIcon","Basics setup");
ViewMap *vM = viewMap();
ViewMap::Iterator _it = vM->begin();
QMap<PDirView*, QWidget*> lst;
for( ; _it != vM->end(); ++_it ) {
PDirView *view = (_it.data())(*m_cfg);
PInterfaceInfo *inf = view->interfaceInfo();
QWidget *_wid = inf->configWidget( *m_cfg );
if (!_wid) continue;
_wid->reparent(wid, QPoint() );
lst.insert( view, _wid );
wid->addTab( _wid, "fileopen", inf->name() );
}
/*
* Add the KeyConfigWidget
*/
Opie::Ui::OKeyConfigWidget* keyWid = new Opie::Ui::OKeyConfigWidget( wid, "key config" );
keyWid->setChangeMode( Opie::Ui::OKeyConfigWidget::Queue );
keyWid->insert( tr("Browser Keyboard Actions"), m_view->manager() );
QWidget*w = m_stack->visibleWidget();
bool reminfo = false;
if ( !m_info ) {
reminfo = true;
initInfo();
m_info->hide();
}
keyWid->insert( tr("Imageinfo Keyboard Actions"), m_info->manager() );
bool remdisp = false;
if ( !m_disp ) {
remdisp = true;
initDisp();
m_disp->hide();
}
keyWid->insert( tr("Imageview Keyboard Actions"), m_disp->manager() );
keyWid->load();
wid->addTab( keyWid, QString::fromLatin1("AppsIcon" ), tr("Keyboard Configuration") );
wid->setCurrentTab(0);
bool act = ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted );
/*
* clean up
*apply changes
*/
QMap<PDirView*, QWidget*>::Iterator it;
for ( it = lst.begin(); it != lst.end(); ++it ) {
if ( act )
it.key()->interfaceInfo()->writeConfig(it.data(), *m_cfg);
delete it.key();
}
if ( act ) {
keyWid->save();
m_disp->manager()->save();
m_info->manager()->save();
m_view->manager()->save();
bSetup->save_values();
m_view->resetView();
readConfig();
}
delete keyWid;
m_stack->raiseWidget(w);
if (remdisp) {
m_disp->hide();
}
if (reminfo) {
m_info->hide();
}
if (m_disp) {
m_disp->setIntensity(m_Intensity,true);
}
}
/*
* create a new image info component
* and detach the current one
* we will make the other delete on exit
*/
template<class T>
void PMainWindow::initT( const char* name, T** ptr, int id) {
if ( *ptr ) {
(*ptr)->disconnect(this, SLOT(slotReturn()));
(*ptr)->setDestructiveClose();
m_stack->removeWidget( *ptr );
}
*ptr = new T(m_cfg, m_stack, name );
m_stack->addWidget( *ptr, id );
connect(*ptr, SIGNAL(sig_return()),
this,SLOT(slotReturn()));
}
void PMainWindow::initInfo() {
initT<imageinfo>( "Image Info", &m_info, ImageInfo );
connect(m_info,SIGNAL(dispImage(const QString&)),this,SLOT(slotDisplay(const QString&)));
}
void PMainWindow::initDisp() {
initT<ImageView>( "Image ScrollView", &m_disp, ImageDisplay );
if (m_disp) {
// if (m_stack->mode() != Opie::Ui::OWidgetStack::SmallScreen) {
//m_disp->setMinimumSize(QApplication::desktop()->size()/2);
// }
m_disp->setMenuActions(m_hGroup,m_gPrevNext,m_gDisplayType,m_hBright);
m_disp->setAutoScale(!m_aUnscaled->isOn());
m_disp->setAutoRotate(m_aAutoRotate->isOn());
m_disp->setShowZoomer(m_aZoomer->isOn());
m_disp->setBackgroundColor(white);
connect(m_disp,SIGNAL(dispImageInfo(const QString&)),this,SLOT(slotShowInfo(const QString&)));
connect(m_disp,SIGNAL(dispNext()),m_view,SLOT(slotShowNext()));
connect(m_disp,SIGNAL(dispPrev()),m_view,SLOT(slotShowPrev()));
connect(m_disp,SIGNAL(toggleFullScreen()),this,SLOT(slotToggleFullScreen()));
connect(m_disp,SIGNAL(hideMe()),this,SLOT(raiseIconView()));
connect(m_disp,SIGNAL(toggleZoomer()),this,SLOT(slotToggleZoomer()));
connect(m_disp,SIGNAL(toggleAutoscale()),this,SLOT(slotToggleAutoscale()));
connect(m_disp,SIGNAL(toggleAutorotate()),this,SLOT(slotToggleAutorotate()));
connect(m_view,SIGNAL(sig_startslide(int)),m_disp,SLOT(startSlide(int)));
connect(m_IncBrightness,SIGNAL(activated()),m_disp,SLOT(slotIncBrightness()));
connect(m_DecBrightness,SIGNAL(activated()),m_disp,SLOT(slotDecBrightness()));
slotFullScreenToggled(m_aFullScreen->isOn());
}
}
void PMainWindow::slotToggleFullScreen()
{
bool current = !m_aFullScreen->isOn();
m_aFullScreen->setOn(current);
}
void PMainWindow::slotFullScreenButton(bool current)
{
if (autoSave) {
m_cfg->writeEntry("fullscreen",current);
}
if (!m_disp) return;
if (m_disp->isVisible()) {
setupViewWindow(current, true);
}
}
void PMainWindow::setupViewWindow(bool current, bool forceDisplay)
{
if (!m_disp) {
return;
}
if (current) {
m_disp->setBackgroundColor(black);
m_disp->reparent(0, WStyle_Customize | WStyle_NoBorderEx, QPoint(0,0));
m_disp->setVScrollBarMode(QScrollView::AlwaysOff);
m_disp->setHScrollBarMode(QScrollView::AlwaysOff);
m_disp->resize(qApp->desktop()->width(), qApp->desktop()->height());
m_disp->setFullScreen(current,forceDisplay);
} else {
setUpdatesEnabled(false);
#if 0
if (m_stack->mode() != Opie::Ui::OWidgetStack::SmallScreen) {
//m_disp->setMinimumSize(QApplication::desktop()->size()/2);
} else {
//m_disp->setMinimumSize(10,10);
}
#endif
m_disp->setBackgroundColor(white);
m_stack->addWidget(m_disp,ImageDisplay);
m_disp->setVScrollBarMode(QScrollView::Auto);
m_disp->setHScrollBarMode(QScrollView::Auto);
if (m_stack->mode() != Opie::Ui::OWidgetStack::SmallScreen) {
m_disp->setGeometry(30,30,QApplication::desktop()->width()-60,QApplication::desktop()->height()-60);
}
if (forceDisplay || m_disp->isVisible()) {
m_stack->raiseWidget(m_disp);
m_disp->setFocus();
}
setUpdatesEnabled(true);
}
m_disp->setFullScreen(current,forceDisplay);
}
void PMainWindow::slotFullScreenToggled(bool current)
{
setupViewWindow(current,true);
}
/**
* With big Screen the plan could be to 'detach' the image
* window if visible and to create a ne wone
* init* already supports it but I make no use of it for
* now. We set filename and raise
*
* ### FIXME and talk to alwin
*/
void PMainWindow::slotShowInfo( const QString& inf ) {
if (m_disp && m_disp->fullScreen() && m_disp->isVisible()) {
return;
}
if ( !m_info ) {
initInfo();
}
m_info->setPath( inf );
if (m_SmallWindow) {
m_aNext->removeFrom(toolBar);
m_aPrevious->removeFrom(toolBar);
fsButton->hide();
}
m_aNext->setEnabled(false);
m_aPrevious->setEnabled(false);
m_aDirUp->setEnabled(false);
m_aShowInfo->setEnabled(false);
m_aViewfile->setEnabled(true);
m_aStartSlide->setEnabled(false);
m_stack->raiseWidget( ImageInfo );
}
void PMainWindow::slotDisplay( const QString& inf ) {
bool nwindow = false;
if ( !m_disp ) {
nwindow = true;
initDisp();
m_disp->setIntensity(m_Intensity);
m_setCurrentBrightness->setEnabled(true);
m_hBright->setEnabled(true);
}
m_disp->setImage( inf );
if (m_SmallWindow) {
if (m_gPrevNext->isEnabled()==false) {
m_gPrevNext->addTo(toolBar);
fsButton->hide();
}
}
m_gPrevNext->setEnabled(true);
m_aDirUp->setEnabled(false);
m_aShowInfo->setEnabled(true);
m_aViewfile->setEnabled(false);
m_aStartSlide->setEnabled(false);
if (!nwindow && m_disp->fullScreen()!=m_aFullScreen->isOn()) {
slotFullScreenToggled(m_aFullScreen->isOn());
}
if (m_disp->fullScreen()) {
if (!m_disp->isVisible()) {
m_disp->showFullScreen();
qwsDisplay()->requestFocus( m_disp->winId(), TRUE);
}
} else {
m_stack->raiseWidget( ImageDisplay );
}
}
void PMainWindow::raiseIconView() {
setUpdatesEnabled(false);
if (m_SmallWindow) {
m_gPrevNext->removeFrom(toolBar);
fsButton->show();
}
m_gPrevNext->setEnabled(false);
m_aDirUp->setEnabled(true);
m_aShowInfo->setEnabled(true);
m_aViewfile->setEnabled(true);
m_aStartSlide->setEnabled(true);
if (m_disp && m_disp->fullScreen() && m_disp->isVisible()) {
m_disp->stopSlide();
m_disp->hide();
}
m_stack->raiseWidget( IconView );
setUpdatesEnabled(true);
repaint();
}
void PMainWindow::slotReturn() {
raiseIconView();
}
void PMainWindow::closeEvent( QCloseEvent* ev ) {
/*
* return from view
* or properly quit
*/
if (!m_setDocCalled) {
if ( m_stack->visibleWidget() == m_info ||
m_stack->visibleWidget() == m_disp ) {
ev->ignore();
raiseIconView();
return;
}
}
if (m_disp && m_disp->fullScreen()) {
/* otherwise opie-eye crashes in bigscreen mode! */
m_disp->reparent(0,QPoint(0,0));
m_stack->addWidget(m_disp,ImageDisplay);
}
ev->accept();
QTimer::singleShot(0, qApp, SLOT(closeAllWindows()));
}
void PMainWindow::setDocument( const QString& showImg )
{
QString file = showImg;
DocLnk lnk(showImg);
if (lnk.isValid() )
file = lnk.file();
slotDisplay( file );
#if 0
if (!m_polishDone) {
QTimer::singleShot(0,this,SLOT(check_view_fullscreen()));
}
#endif
}
void PMainWindow::check_view_fullscreen()
{
if (!m_view) return;
if (!m_view->hasFocus()&&m_aFullScreen->isOn()) {
qwsDisplay()->requestFocus( m_disp->winId(), TRUE);
}
}
void PMainWindow::slotSelectDir(int id)
{
emit changeDir( m_dev[fsMenu->text(id )] );
}
void PMainWindow::dirChanged()
{
fsMenu->clear();
m_dev.clear();
/* home dir, too */
QString f = getenv( "HOME" );
if (!f.isEmpty()) {
m_dev.insert("Home directory",f);
fsMenu->insertItem("Home directory");
}
const QList<FileSystem> &fs = m_storage->fileSystems();
QListIterator<FileSystem> it(fs );
for ( ; it.current(); ++it ) {
const QString disk = (*it)->name();
const QString path = (*it)->path();
m_dev.insert( disk, path );
fsMenu->insertItem( disk );
}
}
void PMainWindow::showToolbar(bool how)
{
if (!how) toolBar->hide();
else toolBar->show();
if (autoSave) {
m_cfg->writeEntry("showtoolbar",how);
}
}
void PMainWindow::setupActions()
{
m_aDirUp = new QAction( tr( "Go dir up" ), Resource::loadIconSet( "up" ), 0, 0, this, 0, true );
m_aDirUp->setToggleAction(false);
connect(m_aDirUp,SIGNAL(activated()),m_view,SLOT(slotDirUp()));
if ( Ir::supported() ) {
m_aBeam = new QAction( tr( "Beam file" ), Resource::loadIconSet( "beam" ),0, 0, this, 0, true );
m_aBeam->setToggleAction(false);
connect(m_aBeam,SIGNAL(activated()),m_view,SLOT(slotBeam()));
} else {
m_aBeam = 0;
}
m_aShowInfo = new QAction( tr( "Show imageinfo" ), Resource::loadIconSet( "edit" ), 0, 0, this, 0, true );
m_aShowInfo->setToggleAction(false);
connect(m_aShowInfo,SIGNAL(activated()),m_view,SLOT(slotImageInfo()));
m_aTrash = new QAction( tr( "Delete file" ), Resource::loadIconSet("trash"), 0, 0, this, 0, true );
m_aTrash->setToggleAction(false);
connect(m_aTrash,SIGNAL(activated()),m_view,SLOT(slotTrash()));
m_aViewfile = new QAction( tr( "Display image" ), Resource::loadIconSet("mag"), 0, 0, this, 0, true );
m_aViewfile->setToggleAction(false);
connect(m_aViewfile,SIGNAL(activated()),m_view,SLOT(slotShowImage()));
m_aStartSlide = new QAction( tr( "Start slideshow" ), Resource::loadIconSet("play"),0, 0, this, 0, true );
m_aStartSlide->setToggleAction(false);
connect(m_aStartSlide,SIGNAL(activated()),m_view,SLOT(slotStartSlide()));
m_aHideToolbar = new QAction( tr( "Show toolbar" ), Resource::loadIconSet( "UtilsIcon" ), 0, 0, this, 0, true );
m_aHideToolbar->setOn (true);
connect(m_aHideToolbar,SIGNAL(toggled(bool)),this,SLOT(showToolbar(bool)));
m_aSetup = new QAction( tr( "Settings" ), Resource::loadIconSet("SettingsIcon"), 0, 0, this, 0, true );
m_aSetup->setToggleAction(false);
connect(m_aSetup,SIGNAL(activated()),this,SLOT(slotConfig()));
m_gListViewMode = new QActionGroup(this,"Select listmode",true);
connect(m_gListViewMode,SIGNAL(selected(QAction*)),this,SLOT(listviewselected(QAction*)));
m_aDirLong = new QAction( tr( "Thumbnail and Imageinfo" ),Resource::loadIconSet("opie-eye/opie-eye-thumb"), 0, 0, this, 0, true );
m_aDirLong->setToggleAction(true);
m_aDirShort = new QAction( tr( "Thumbnail and name" ),Resource::loadIconSet("opie-eye/opie-eye-thumbonly"), 0, 0, this, 0, true );
m_aDirShort->setToggleAction(true);
m_aDirName = new QAction( tr( "Name only" ), Resource::loadIconSet("opie-eye/opie-eye-textview"),0, 0, this, 0, true );
m_aDirName->setToggleAction(true);
int mode = m_cfg->readNumEntry("ListViewMode", 1);
if (mode < 1 || mode>3) mode = 1;
switch (mode) {
case 3:
m_aDirName->setOn(true);
break;
case 2:
m_aDirShort->setOn(true);
break;
case 1:
default:
m_aDirLong->setOn(true);
}
m_gListViewMode->insert(m_aDirLong);
m_gListViewMode->insert(m_aDirShort);
m_gListViewMode->insert(m_aDirName);
m_gPrevNext = new QActionGroup(this,"imageprevnext",false);
m_aNext = new QAction( tr( "Next image" ), Resource::loadIconSet("forward"), 0, 0, this, 0, true );
m_aNext->setToggleAction(false);
connect(m_aNext,SIGNAL(activated()),m_view,SLOT(slotShowNext()));
m_aPrevious = new QAction( tr( "Previous image" ), Resource::loadIconSet("back"), 0, 0, this, 0, true );
m_aPrevious->setToggleAction(false);
connect(m_aPrevious,SIGNAL(activated()),m_view,SLOT(slotShowPrev()));
m_gPrevNext->insert(m_aPrevious);
m_gPrevNext->insert(m_aNext);
m_aFullScreen = new QAction( tr( "Show images fullscreen" ),
Resource::loadIconSet("fullscreen"), 0, 0, this, 0, true );
m_aFullScreen->setToggleAction(true);
if (autoSave) {
m_aFullScreen->setOn(m_cfg->readBoolEntry("fullscreen",false));
} else {
m_aFullScreen->setOn(false);
}
connect(m_aFullScreen,SIGNAL(toggled(bool)),this,SLOT(slotFullScreenButton(bool)));
m_gDisplayType = new QActionGroup(this,"imagedisplaytype",false);
m_aAutoRotate = new QAction( tr( "Auto rotate images" ), Resource::loadIconSet( "rotate" ), 0, 0, this, 0, true );
m_aAutoRotate->setToggleAction(true);
if (m_stack->mode() == Opie::Ui::OWidgetStack::SmallScreen) {
m_aAutoRotate->setOn(true);
} else {
m_aAutoRotate->setOn(false);
}
if (autoSave) {
m_aAutoRotate->setOn(m_cfg->readBoolEntry("autorotate",m_aAutoRotate->isOn()));
}
connect(m_aAutoRotate,SIGNAL(toggled(bool)),this,SLOT(slotRotateToggled(bool)));
m_aUnscaled = new QAction( tr( "Show images unscaled" ), Resource::loadIconSet( "1to1" ), 0, 0, this, 0, true );
m_aUnscaled->setToggleAction(true);
connect(m_aUnscaled,SIGNAL(toggled(bool)),this,SLOT(slotScaleToggled(bool)));
if (autoSave) {
m_aUnscaled->setOn(m_cfg->readBoolEntry("unscaled",false));
} else {
m_aUnscaled->setOn(false);
}
m_aZoomer = new QAction( tr( "Show zoomer window when unscaled" ), Resource::loadIconSet( "mag" ), 0, 0, this, 0, true );
m_aZoomer->setToggleAction(true);
if (autoSave) {
m_aZoomer->setOn(m_cfg->readBoolEntry("zoomeron",true));
} else {
m_aZoomer->setOn (true);
}
connect(m_aZoomer,SIGNAL(toggled(bool)),this,SLOT(slotZoomerToggled(bool)));
m_gDisplayType->insert(m_aAutoRotate);
m_gDisplayType->insert(m_aUnscaled);
m_gDisplayType->insert(m_aZoomer);
m_hGroup = new QActionGroup(this,"actioncollection",false);
m_hGroup->insert(m_aFullScreen);
if (!m_SmallWindow) {
m_aForceSmall = new QAction(tr("Dont show seperate windows"),Resource::loadIconSet( "AppsIcon" ), 0, 0, this, 0, true);
m_aForceSmall->setToggleAction(true);
connect(m_aForceSmall,SIGNAL(toggled(bool)),this,SLOT(slotForceSmall(bool)));
} else {
m_aForceSmall = 0;
}
m_setCurrentBrightness = new QAction(tr("Display brightness..."), 0, 0, this, 0, false);
connect(m_setCurrentBrightness,SIGNAL(activated()),this,SLOT(setupBrightness()));
m_IncBrightness = new QAction(tr("Increase brightness by 5"),Resource::loadIconSet( "up" ),0, 0, this, 0, false);
m_DecBrightness = new QAction(tr("Decrease brightness by 5"),Resource::loadIconSet( "down" ),0, 0, this, 0, false);
m_hBright = new QActionGroup(this,"actioncollection",false),
+ m_hBright->insert(m_setCurrentBrightness);
m_hBright->insert(m_IncBrightness);
m_hBright->insert(m_DecBrightness);
}
void PMainWindow::setupBrightness()
{
if (!m_disp) {
return;
}
+ bool reshow=false;
+ if (m_disp->isVisible()&&m_disp->fullScreen()) {
+ m_disp->hide();
+ reshow = true;
+ }
int lb = m_disp->Intensity();
if (Valuebox(0,-100,100,lb,lb)) {
m_disp->setIntensity(lb,true);
}
+ if (reshow) {
+ m_disp->showFullScreen();
+ qwsDisplay()->requestFocus( m_disp->winId(), TRUE);
+ }
}
void PMainWindow::setupToolbar()
{
toolBar = new QToolBar( this );
addToolBar(toolBar);
toolBar->setHorizontalStretchable( true );
setToolBarsMovable( false );
m_aDirUp->addTo( toolBar );
fsButton = new PFileSystem( toolBar );
connect( fsButton, SIGNAL( changeDir( const QString& ) ),
m_view, SLOT(slotChangeDir( const QString& ) ) );
connect( this, SIGNAL( changeDir( const QString& ) ),
m_view, SLOT(slotChangeDir( const QString& ) ) );
if (m_aBeam) {
m_aBeam->addTo( toolBar );
}
m_aShowInfo->addTo(toolBar);
m_aTrash->addTo(toolBar);
-// m_aSetup->addTo(toolBar);
m_gDisplayType->addTo(toolBar);
if (!m_SmallWindow) {
m_gPrevNext->addTo(toolBar);
} else {
m_gPrevNext->setEnabled(false);
}
}
void PMainWindow::setupMenu()
{
fileMenu = new QPopupMenu( menuBar() );
menuBar()->insertItem( tr( "File" ), fileMenu );
dispMenu = new QPopupMenu( menuBar() );
menuBar()->insertItem( tr( "Show" ), dispMenu );
settingsMenu = new QPopupMenu( menuBar() );
menuBar()->insertItem( tr( "Settings" ), settingsMenu );
m_aViewfile->addTo(fileMenu);
m_aShowInfo->addTo(fileMenu);
m_aStartSlide->addTo(fileMenu);
fileMenu->insertSeparator();
m_aDirUp->addTo( fileMenu );
fsMenu = new QPopupMenu(fileMenu);
fileMenu->insertItem(Resource::loadIconSet( "cardmon/pcmcia" ),tr("Select filesystem"),fsMenu);
connect( fsMenu, SIGNAL( activated( int ) ), this, SLOT(slotSelectDir( int ) ) );
dirChanged();
if ( m_aBeam ) {
fileMenu->insertSeparator();
m_aBeam->addTo( fileMenu );
}
fileMenu->insertSeparator();
m_aTrash->addTo(fileMenu);
listviewMenu = new QPopupMenu(dispMenu);
dispMenu->insertItem(Resource::loadIconSet("opie-eye/opie-eye-thumb"),tr("Listview mode"),listviewMenu);
m_gListViewMode->addTo(listviewMenu);
dispMenu->insertSeparator();
m_aFullScreen->addTo(dispMenu);
m_gDisplayType->addTo(dispMenu);
dispMenu->insertSeparator();
m_gPrevNext->addTo(dispMenu);
- m_setCurrentBrightness->addTo(dispMenu);
- m_setCurrentBrightness->setEnabled(false);
dispMenu->insertSeparator();
m_hBright->addTo(dispMenu);
m_hBright->setEnabled(false);
if (m_aForceSmall) {
dispMenu->insertSeparator();
m_aForceSmall->addTo(dispMenu);
}
m_aSetup->addTo(settingsMenu);
m_aHideToolbar->addTo(settingsMenu);
}
void PMainWindow::listviewselected(QAction*which)
{
if (!which || which->isOn()==false) return;
int val = 1;
if (which==m_aDirName) {
val = 3;
} else if (which==m_aDirShort) {
val = 2;
} else if (which==m_aDirLong) {
val = 1;
}
emit changeListMode(val);
}
void PMainWindow::readConfig()
{
autoSave =m_cfg->readBoolEntry("savestatus",true);
m_Intensity = m_cfg->readNumEntry("intensity",0);
}
void PMainWindow::polish()
{
if (m_disp) {
odebug << "======================\n"
<< "Called via setdocument\n"
<< "======================" << oendl;
m_setDocCalled = true;
m_view->setDoccalled(true);
m_disp->setCloseIfHide(true);
} else {
m_setDocCalled = false;
m_view->setDoccalled(false);
}
m_polishDone = true;
QMainWindow::polish();
if (m_setDocCalled) {
if (m_aFullScreen->isOn()) {
QTimer::singleShot(0,this,SLOT(check_view_fullscreen()));
} else if (m_stack->mode() != Opie::Ui::OWidgetStack::SmallScreen) {
}
}
}
void PMainWindow::slotForceSmall(bool how)
{
odebug << "Disable separate windows: " << how << oendl;
if (m_stack) {
if (how) {
m_stack->forceMode(Opie::Ui::OWidgetStack::SmallScreen);
} else {
m_stack->forceMode(Opie::Ui::OWidgetStack::NoForce);
}
}
if (autoSave) {
m_cfg->writeEntry("dontshowseperate",how);
}
}
bool PMainWindow::Valuebox(QWidget*parent,int min, int max, int current,int&store)
{
QDialog dlg(parent,"brightnessbox",true);
QVBoxLayout * m_MainLayout;
QGridLayout * m_IntensityLayout;
QSpinBox * m_Intensity;
QLabel * m_IntensityLabel;
m_MainLayout = new QVBoxLayout( &dlg, 11, 6, "m_MainLayout");
m_IntensityLayout = new QGridLayout( 0, 1, 1, 0, 6, "m_IntensityLayout");
m_Intensity = new QSpinBox( &dlg, "m_Intensity" );
m_Intensity->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed));
m_Intensity->setButtonSymbols( QSpinBox::PlusMinus );
m_Intensity->setMaxValue( max );
m_Intensity->setMinValue(min);
m_Intensity->setValue( current );
m_IntensityLayout->addWidget( m_Intensity, 0, 1 );
m_IntensityLabel = new QLabel( &dlg, "m_IntensityLabel" );
m_IntensityLabel->setText(QObject::tr("Display brightness:"));
m_IntensityLayout->addWidget(m_IntensityLabel, 0, 0 );
m_MainLayout->addLayout(m_IntensityLayout);
if (dlg.exec()) {
store = m_Intensity->value();
return true;
}
return false;
}