summaryrefslogtreecommitdiffstats
path: root/kooka/kookaview.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kooka/kookaview.cpp
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kooka/kookaview.cpp')
-rw-r--r--kooka/kookaview.cpp1083
1 files changed, 1083 insertions, 0 deletions
diff --git a/kooka/kookaview.cpp b/kooka/kookaview.cpp
new file mode 100644
index 00000000..f1c1d8d0
--- /dev/null
+++ b/kooka/kookaview.cpp
@@ -0,0 +1,1083 @@
+/***************************************************************************
+ kookaview.cpp - kookas visible stuff
+ -------------------
+ begin : ?
+ copyright : (C) 1999 by Klaas Freitag
+ email : freitag@suse.de
+
+ $Id$
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This file may be distributed and/or modified under the terms of the *
+ * GNU General Public License version 2 as published by the Free Software *
+ * Foundation and appearing in the file COPYING included in the *
+ * packaging of this file. *
+ *
+ * As a special exception, permission is given to link this program *
+ * with any version of the KADMOS ocr/icr engine of reRecognition GmbH, *
+ * Kreuzlingen and distribute the resulting executable without *
+ * including the source code for KADMOS in the source distribution. *
+ *
+ * As a special exception, permission is given to link this program *
+ * with any edition of Qt, and distribute the resulting executable, *
+ * without including the source code for Qt in the source distribution. *
+ * *
+ ***************************************************************************/
+
+#include "kookaview.h"
+#include "resource.h"
+#include "kscandevice.h"
+#include "imgscaninfo.h"
+#include "devselector.h"
+#include "ksaneocr.h"
+#include "img_saver.h"
+#include "kookapref.h"
+#include "imgnamecombo.h"
+#include "thumbview.h"
+#include "dwmenuaction.h"
+#include "kookaimage.h"
+#include "kookaimagemeta.h"
+#include "ocrresedit.h"
+#include "kookaprint.h"
+#include "imgprintdialog.h"
+#if 0
+#include "paramsetdialogs.h"
+#endif
+#include <qlabel.h>
+#include <qpainter.h>
+#include <qlayout.h>
+#include <qsplitter.h>
+#include <qstrlist.h>
+#include <qpaintdevice.h>
+#include <qpaintdevicemetrics.h>
+#include <qpopupmenu.h>
+#include <qwidgetstack.h>
+
+#include <kurl.h>
+#include <krun.h>
+#include <kapplication.h>
+#include <kstatusbar.h>
+#include <kconfig.h>
+#include <kdebug.h>
+#include <ktrader.h>
+#include <klibloader.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <keditcl.h>
+#include <kled.h>
+#include <kcombobox.h>
+#include <kaction.h>
+#include <kiconloader.h>
+#include <kshortcut.h>
+#include <kdockwidget.h>
+#include <qobject.h>
+
+#include <kparts/componentfactory.h>
+#include <qimage.h>
+#include <kpopupmenu.h>
+
+
+#define STARTUP_IMG_SELECTION "SelectedImageOnStartup"
+
+
+KookaView::KookaView( KParts::DockMainWindow *parent, const QCString& deviceToUse)
+ : QObject(),
+ m_ocrResultImg(0),
+ ocrFabric(0),
+ m_mainDock(0),
+ m_dockScanParam(0),
+ m_dockThumbs(0),
+ m_dockPackager(0),
+ m_dockRecent(0),
+ m_dockPreview(0),
+ m_dockOCRText(0),
+ m_mainWindow(parent),
+ m_ocrResEdit(0)
+{
+ KIconLoader *loader = KGlobal::iconLoader();
+ scan_params = 0L;
+ preview_canvas = 0L;
+
+ m_mainDock = parent->createDockWidget( "Kookas MainDock",
+ loader->loadIcon( "folder_image", KIcon::Small ),
+ 0L, i18n("Image Viewer"));
+ m_mainDock->setEnableDocking(KDockWidget::DockNone );
+ m_mainDock->setDockSite( KDockWidget::DockFullSite );
+
+ parent->setView( m_mainDock);
+ parent->setMainDockWidget( m_mainDock);
+
+ img_canvas = new ImageCanvas( m_mainDock );
+ img_canvas->setMinimumSize(100,200);
+ img_canvas->enableContextMenu(true);
+ connect( img_canvas, SIGNAL( imageReadOnly(bool)),
+ this, SLOT(slViewerReadOnly(bool)));
+
+ KPopupMenu *ctxtmenu = static_cast<KPopupMenu*>(img_canvas->contextMenu());
+ if( ctxtmenu )
+ ctxtmenu->insertTitle(i18n("Image View"));
+ m_mainDock->setWidget( img_canvas );
+
+ /** Thumbview **/
+ m_dockThumbs = parent->createDockWidget( "Thumbs",
+ loader->loadIcon( "thumbnail", KIcon::Small ),
+ 0L, i18n("Thumbnails"));
+ m_dockThumbs->setDockSite(KDockWidget::DockFullSite );
+
+ /* thumbnail viewer widget */
+ m_thumbview = new ThumbView( m_dockThumbs);
+ m_dockThumbs->setWidget( m_thumbview );
+
+ m_dockThumbs->manualDock( m_mainDock, // dock target
+ KDockWidget::DockBottom, // dock site
+ 20 ); // relation target/this (in percent)
+
+ /** Packager Dock **/
+ /* A new packager to contain the already scanned images */
+ m_dockPackager = parent->createDockWidget( "Scanpackager",
+ loader->loadIcon( "palette_color", KIcon::Small ),
+ 0L, i18n("Gallery"));
+ m_dockPackager->setDockSite(KDockWidget::DockFullSite);
+ packager = new ScanPackager( m_dockPackager );
+ m_dockPackager->setWidget( packager );
+ m_dockPackager->manualDock( m_mainDock, // dock target
+ KDockWidget::DockLeft, // dock site
+ 30 ); // relation target/this (in percent)
+
+
+ connect( packager, SIGNAL(showThumbnails( KFileTreeViewItem* )),
+ this, SLOT( slShowThumbnails( KFileTreeViewItem* )));
+ connect( m_thumbview, SIGNAL( selectFromThumbnail( const KURL& )),
+ packager, SLOT( slSelectImage(const KURL&)));
+
+ /*
+ * Create a Kombobox that holds the last folders visible even on the preview page
+ */
+ m_dockRecent = parent->createDockWidget( "Recent",
+ loader->loadIcon( "image", KIcon::Small ),
+ 0L, i18n("Gallery Folders"));
+
+ m_dockRecent->setDockSite(KDockWidget::DockFullSite);
+
+ QHBox *recentBox = new QHBox( m_dockRecent );
+ recentBox->setMargin(KDialog::marginHint());
+ QLabel *lab = new QLabel( i18n("Gallery:"), recentBox );
+ lab->setSizePolicy( QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed) );
+ recentFolder = new ImageNameCombo( recentBox );
+
+ m_dockRecent->setWidget( recentBox );
+ m_dockRecent->manualDock( m_dockPackager, // dock target
+ KDockWidget::DockBottom, // dock site
+ 5 ); // relation target/this (in percent)
+
+
+
+ connect( packager, SIGNAL( galleryPathSelected( KFileTreeBranch*, const QString&)),
+ recentFolder, SLOT( slotGalleryPathChanged( KFileTreeBranch*, const QString& )));
+
+ connect( packager, SIGNAL( directoryToRemove( KFileTreeBranch*, const QString&)),
+ recentFolder, SLOT( slotPathRemove( KFileTreeBranch*, const QString& )));
+
+ connect( recentFolder, SIGNAL(activated( const QString& )),
+ packager, SLOT(slotSelectDirectory( const QString& )));
+
+ /* the object from the kscan lib to handle low level scanning */
+ m_dockScanParam = parent->createDockWidget( "Scan Parameter",
+ loader->loadIcon( "folder", KIcon::Small ),
+ 0L, i18n("Scan Parameter"));
+ //
+ m_dockScanParam->setDockSite(KDockWidget::DockFullSite);
+
+ m_dockScanParam->setWidget( 0 ); // later
+ sane = new KScanDevice( m_dockScanParam );
+ Q_CHECK_PTR(sane);
+
+ m_dockScanParam->manualDock( m_dockRecent, // dock target
+ KDockWidget::DockBottom, // dock site
+ 20 ); // relation target/this (in percent)
+ m_dockScanParam->hide();
+
+ /* select the scan device, either user or from config, this creates and assembles
+ * the complete scanner options dialog
+ * scan_params must be zero for that */
+
+ m_dockPreview = parent->createDockWidget( "Preview ",
+ loader->loadIcon( "viewmag", KIcon::Small ),
+ 0L, i18n("Scan Preview"));
+
+ preview_canvas = new Previewer( m_dockPreview );
+ {
+ preview_canvas->setMinimumSize( 100,100);
+
+ /* since the scan_params will be created in slSelectDevice, do the
+ * connections later
+ */
+ }
+ m_dockPreview->setWidget( preview_canvas );
+ m_dockPreview->manualDock( m_mainDock, // dock target
+ KDockWidget::DockCenter, // dock site
+ 100 ); // relation target/this (in percent)
+
+ /* Create a text editor part for ocr results */
+
+ m_dockOCRText = parent->createDockWidget( "OCRResults",
+ loader->loadIcon("edit", KIcon::Small ),
+ 0L, i18n("OCR Result Text"));
+ // m_textEdit
+ m_ocrResEdit = new ocrResEdit( m_dockOCRText );
+
+ if( m_ocrResEdit )
+ {
+ m_dockOCRText->setWidget( m_ocrResEdit ); // m_textEdit->widget() );
+ m_dockOCRText->manualDock( m_dockThumbs, // dock target
+ KDockWidget::DockCenter, // dock site
+ 100 ); // relation target/this (in percent)
+
+ m_ocrResEdit->setTextFormat( Qt::PlainText );
+ m_ocrResEdit->setWordWrap( QTextEdit::NoWrap );
+ // m_dockOCRText->hide();
+ }
+
+ if( slSelectDevice(deviceToUse))
+ {
+ /* Load from config which tab page was selected last time */
+ }
+
+ /* New image created after scanning */
+ connect(sane, SIGNAL(sigNewImage(QImage*,ImgScanInfo*)), this, SLOT(slNewImageScanned(QImage*,ImgScanInfo*)));
+ /* New preview image */
+ connect(sane, SIGNAL(sigNewPreview(QImage*,ImgScanInfo *)), this, SLOT( slNewPreview(QImage*,ImgScanInfo *)));
+
+ connect( sane, SIGNAL( sigScanStart() ), this, SLOT( slScanStart()));
+ connect( sane, SIGNAL( sigScanFinished(KScanStat)), this, SLOT(slScanFinished(KScanStat)));
+ connect( sane, SIGNAL( sigAcquireStart()), this, SLOT( slAcquireStart()));
+ /* Image canvas should show a new document */
+ connect( packager, SIGNAL( showImage( KookaImage* )),
+ this, SLOT( slShowAImage( KookaImage*)));
+
+ connect( packager, SIGNAL( aboutToShowImage(const KURL&)),
+ this, SLOT( slStartLoading( const KURL& )));
+
+ /* Packager unloads the image */
+ connect( packager, SIGNAL( unloadImage( KookaImage* )),
+ this, SLOT( slUnloadAImage( KookaImage*)));
+
+ /* a image changed mostly through a image manipulation method like rotate */
+ connect( packager, SIGNAL( fileChanged( KFileItem* )),
+ m_thumbview, SLOT( slImageChanged( KFileItem* )));
+
+ connect( packager, SIGNAL( fileRenamed( KFileItem*, const KURL& )),
+ m_thumbview, SLOT( slImageRenamed( KFileItem*, const KURL& )));
+
+ connect( packager, SIGNAL( fileDeleted( KFileItem* )),
+ m_thumbview, SLOT( slImageDeleted( KFileItem* )));
+
+
+ packager->openRoots();
+
+ /* Status Bar */
+ KStatusBar *statBar = m_mainWindow->statusBar();
+
+ // statBar->insertItem(QString("1"), SBAR_ZOOM, 0, true );
+ statBar->insertItem( QString("-"), StatusImage, 0, true );
+
+ /* Set a large enough size */
+ int w = statBar->fontMetrics().
+ width(img_canvas->imageInfoString(2000, 2000, 48));
+ kdDebug(28000) << "Fixed size for status bar: " << w << " from string " << img_canvas->imageInfoString(2000, 2000, 48) << endl;
+ statBar->setItemFixed( StatusImage, w );
+
+}
+
+
+KookaView::~KookaView()
+{
+ saveProperties( KGlobal::config () );
+ delete preview_canvas;
+
+ kdDebug(28000)<< "Finished saving config data" << endl;
+}
+
+void KookaView::slViewerReadOnly( bool )
+{
+ /* retrieve actions that could change the image */
+}
+
+
+bool KookaView::slSelectDevice( const QCString& useDevice )
+{
+
+ kdDebug(28000) << "Kookaview: select a device!" << endl;
+ bool haveConnection = false;
+
+ QCString selDevice;
+ /* in case useDevice is the term 'gallery', the user does not want to
+ * connect to a scanner, but only work in gallery mode. Otherwise, try
+ * to read the device to use from config or from a user dialog */
+ if( useDevice != "gallery" )
+ {
+ selDevice = useDevice;
+ if( selDevice.isEmpty())
+ {
+ selDevice = userDeviceSelection();
+ }
+ }
+
+ if( !selDevice.isEmpty() )
+ {
+ kdDebug(28000) << "Opening device " << selDevice << endl;
+
+ if( connectedDevice == selDevice ) {
+ kdDebug( 28000) << "Device " << selDevice << " is already selected!" << endl;
+ return( true );
+ }
+
+ if( scan_params )
+ {
+ /* This deletes the existing scan_params^-object */
+ slCloseScanDevice();
+ }
+
+ /* This connects to the selected scanner */
+ scan_params = new ScanParams( m_dockScanParam );
+ Q_CHECK_PTR(scan_params);
+
+ if( sane->openDevice( selDevice ) == KSCAN_OK )
+ {
+ connect( scan_params, SIGNAL( scanResolutionChanged( int, int )),
+ preview_canvas, SLOT( slNewScanResolutions( int, int )));
+
+ if( ! scan_params->connectDevice( sane ) )
+ {
+ kdDebug(28000) << "Connecting to the scanner failed :( ->TODO" << endl;
+ }
+ else
+ {
+ haveConnection = true;
+ connectedDevice = selDevice;
+
+ /* New Rectangle selection in the preview, now scanimge exists */
+ ImageCanvas *previewCanvas = preview_canvas->getImageCanvas();
+ connect( previewCanvas , SIGNAL( newRect(QRect)),
+ scan_params, SLOT(slCustomScanSize(QRect)));
+ connect( previewCanvas, SIGNAL( noRect()),
+ scan_params, SLOT(slMaximalScanSize()));
+ // connect( scan_params, SIGNAL( scanResolutionChanged( int, int )),
+ // preview_canvas, SLOT( slNewScanResolutions( int, int )));
+ /* load the preview image */
+ if( preview_canvas )
+ {
+ preview_canvas->setPreviewImage( sane->loadPreviewImage() );
+
+ /* Call this after the devic is actually open */
+ preview_canvas->slConnectScanner( sane );
+ }
+ }
+ }
+ else
+ {
+ kdDebug(28000) << "Could not open device <" << selDevice << ">" << endl;
+ scan_params->connectDevice(0);
+ }
+
+ /* show the widget again */
+
+ m_dockScanParam->setWidget( scan_params );
+
+ m_dockScanParam->show();
+ }
+ else
+ {
+ // no devices available or starting in gallery mode
+ if( scan_params )
+ scan_params->connectDevice( 0L );
+ }
+ return( haveConnection );
+}
+
+QCString KookaView::userDeviceSelection( ) const
+{
+ /* Human readable scanner descriptions */
+ QStringList hrbackends;
+
+ /* a list of backends the scan backend knows */
+ QStrList backends = sane->getDevices();
+ QStrListIterator it( backends );
+
+ QCString selDevice;
+ if( backends.count() > 0 )
+ {
+ while( it )
+ {
+ kdDebug( 28000 ) << "Found backend: " << it.current() << endl;
+ hrbackends.append( sane->getScannerName( it.current() ));
+ ++it;
+ }
+
+ /* allow the user to select one */
+ DeviceSelector ds( 0, backends, hrbackends );
+ selDevice = ds.getDeviceFromConfig( );
+
+ if( selDevice.isEmpty() || selDevice.isNull() )
+ {
+ kdDebug(29000) << "selDevice not found - starting selector!" << selDevice << endl;
+ if ( ds.exec() == QDialog::Accepted )
+ {
+ selDevice = ds.getSelectedDevice();
+ }
+ }
+ }
+ return( selDevice );
+}
+
+
+void KookaView::loadStartupImage( void )
+{
+ kdDebug( 28000) << "Starting to load startup image" << endl;
+
+ /* Now set the configured stuff */
+ KConfig *konf = KGlobal::config ();
+ if( konf )
+ {
+ konf->setGroup(GROUP_STARTUP);
+ bool wantReadOnStart = konf->readBoolEntry( STARTUP_READ_IMAGE, true );
+
+ if( wantReadOnStart )
+ {
+ QString startup = konf->readPathEntry( STARTUP_IMG_SELECTION );
+
+ if( !startup.isEmpty() )
+ {
+ kdDebug(28000) << "Loading startup image !" << endl;
+ packager->slSelectImage( KURL(startup) );
+ }
+ }
+ else
+ {
+ kdDebug(28000) << "Do not load startup image due to config value" << endl;
+ }
+ }
+}
+
+
+void KookaView::print()
+{
+ /* For now, print a single file. Later, print multiple images to one page */
+ KookaImage *img = packager->getCurrImage();
+ if ( !img )
+ return;
+ KPrinter printer; // ( true, pMode );
+ printer.setUsePrinterResolution(true);
+ printer.addDialogPage( new ImgPrintDialog( img ));
+
+ if( printer.setup( m_mainWindow, i18n("Print %1").arg(img->localFileName().section('/', -1)) ))
+ {
+ KookaPrint kookaprint( &printer );
+ kookaprint.printImage(img);
+ }
+}
+
+void KookaView::slNewPreview( QImage *new_img, ImgScanInfo * )
+{
+ if( new_img )
+ {
+ if( ! new_img->isNull() )
+ {
+ /* flip preview to front */
+ m_dockPreview->makeDockVisible();
+ }
+ preview_canvas->newImage( new_img );
+ }
+}
+
+
+bool KookaView::ToggleVisibility( int item )
+{
+ QWidget *w = 0;
+ bool ret = false;
+
+ switch( item )
+ {
+ case ID_VIEW_SCANPARAMS:
+ w = scan_params;
+ break;
+ case ID_VIEW_POOL:
+ w = preview_canvas;
+ break;
+ default:
+ w = 0;
+ }
+
+ if( w )
+ {
+ if( w->isVisible() )
+ {
+ w->hide();
+ ret = false;
+ }
+ else
+ {
+ w->show();
+ ret = true;
+ }
+ }
+ return ret;
+}
+
+
+void KookaView::doOCRonSelection( void )
+{
+ emit( signalChangeStatusbar( i18n("Starting OCR on selection" )));
+
+ KookaImage img;
+
+ if( img_canvas->selectedImage(&img) )
+ {
+ startOCR( &img );
+ }
+ emit( signalCleanStatusbar() );
+}
+
+/* Does OCR on the entire picture */
+void KookaView::doOCR( void )
+{
+ emit( signalChangeStatusbar( i18n("Starting OCR on the entire image" )));
+ KookaImage *img = packager->getCurrImage();
+ startOCR( img );
+ emit( signalCleanStatusbar( ));
+}
+
+void KookaView::startOCR( KookaImage *img )
+{
+ if( img && ! img->isNull() )
+ {
+ if( ocrFabric == 0L )
+ {
+ ocrFabric = new KSANEOCR( m_mainDock, KGlobal::config() );
+ ocrFabric->setImageCanvas( img_canvas );
+
+ connect( ocrFabric, SIGNAL( newOCRResultText( const QString& )),
+ m_ocrResEdit, SLOT(setText( const QString& )));
+
+ connect( ocrFabric, SIGNAL( newOCRResultText( const QString& )),
+ m_dockOCRText, SLOT( show() ));
+
+ connect( ocrFabric, SIGNAL( repaintOCRResImage( )),
+ img_canvas, SLOT(repaint()));
+
+ connect( ocrFabric, SIGNAL( clearOCRResultText()),
+ m_ocrResEdit, SLOT(clear()));
+
+ connect( ocrFabric, SIGNAL( updateWord(int, const QString&, const QString& )),
+ m_ocrResEdit, SLOT( slUpdateOCRResult( int, const QString&, const QString& )));
+
+ connect( ocrFabric, SIGNAL( ignoreWord(int, const ocrWord&)),
+ m_ocrResEdit, SLOT( slIgnoreWrongWord( int, const ocrWord& )));
+
+ connect( ocrFabric, SIGNAL( markWordWrong(int, const ocrWord& )),
+ m_ocrResEdit, SLOT( slMarkWordWrong( int, const ocrWord& )));
+
+ connect( ocrFabric, SIGNAL( readOnlyEditor( bool )),
+ m_ocrResEdit, SLOT( setReadOnly( bool )));
+
+ connect( ocrFabric, SIGNAL( selectWord( int, const ocrWord& )),
+ m_ocrResEdit, SLOT( slSelectWord( int, const ocrWord& )));
+
+ }
+
+ Q_CHECK_PTR( ocrFabric );
+ ocrFabric->slSetImage( img );
+
+ if( !ocrFabric->startOCRVisible(m_mainDock) )
+ {
+ KMessageBox::sorry(0, i18n("Could not start OCR-Process.\n"
+ "Probably there is already one running." ));
+
+ }
+ }
+}
+
+
+void KookaView::slOCRResultImage( const QPixmap& pix )
+{
+ kdDebug(28000) << "Showing OCR Result Image" << endl;
+ if( ! img_canvas ) return;
+
+ if( m_ocrResultImg )
+ {
+ img_canvas->newImage(0L);
+ delete m_ocrResultImg;
+ }
+
+ m_ocrResultImg = new QImage();
+ *m_ocrResultImg = pix;
+ img_canvas->newImage( m_ocrResultImg );
+ img_canvas->setReadOnly(true); // ocr result images should be read only.
+}
+
+void KookaView::slScanStart( )
+{
+ kdDebug(28000) << "Scan starts " << endl;
+ if( scan_params )
+ {
+ scan_params->setEnabled( false );
+ KLed *led = scan_params->operationLED();
+ if( led )
+ {
+ led->setColor( Qt::red );
+ led->setState( KLed::On );
+ }
+ }
+}
+
+void KookaView::slAcquireStart( )
+{
+ kdDebug(28000) << "Acquire starts " << endl;
+ if( scan_params )
+ {
+ KLed *led = scan_params->operationLED();
+ if( led )
+ {
+ led->setColor( Qt::green );
+ }
+ }
+}
+
+void KookaView::slNewImageScanned( QImage* img, ImgScanInfo* si )
+{
+ KookaImageMeta *meta = new KookaImageMeta;
+ meta->setScanResolution(si->getXResolution(), si->getYResolution());
+ packager->slAddImage(img, meta);
+}
+
+
+
+void KookaView::slScanFinished( KScanStat stat )
+{
+ kdDebug(28000) << "Scan finished with status " << stat << endl;
+ if( scan_params )
+ {
+ scan_params->setEnabled( true );
+ KLed *led = scan_params->operationLED();
+ if( led )
+ {
+ led->setColor( Qt::green );
+ led->setState( KLed::Off );
+ }
+ }
+}
+
+
+void KookaView::slCloseScanDevice( )
+{
+ kdDebug(28000) << "Scanner Device closes down !" << endl;
+ if( scan_params ) {
+ delete scan_params;
+ scan_params = 0;
+ m_dockScanParam->setWidget(0L);
+ m_dockScanParam->hide();
+ }
+
+ sane->slCloseDevice();
+}
+
+void KookaView::slCreateNewImgFromSelection()
+{
+ if( img_canvas->rootImage() )
+ {
+ emit( signalChangeStatusbar( i18n("Create new image from selection" )));
+ QImage img;
+ if( img_canvas->selectedImage( &img ) )
+ {
+ packager->slAddImage( &img );
+ }
+ emit( signalCleanStatusbar( ));
+ }
+
+}
+
+
+void KookaView::slRotateImage(int angle)
+{
+ // QImage *img = (QImage*) img_canvas->rootImage();
+ KookaImage *img = packager->getCurrImage();
+ bool doUpdate = true;
+
+ if( img )
+ {
+ QImage resImg;
+
+ QApplication::setOverrideCursor(waitCursor);
+ switch( angle )
+ {
+ case 90:
+ emit( signalChangeStatusbar( i18n("Rotate image 90 degrees" )));
+ resImg = rotateRight( img );
+ break;
+ case 180:
+ emit( signalChangeStatusbar( i18n("Rotate image 180 degrees" )));
+ resImg = rotate180( img );
+ break;
+ case 270:
+ case -90:
+ emit( signalChangeStatusbar( i18n("Rotate image -90 degrees" )));
+ resImg = rotateLeft( img );
+
+ break;
+ default:
+ kdDebug(28000) << "Not supported yet !" << endl;
+ doUpdate = false;
+
+ break;
+ }
+ QApplication::restoreOverrideCursor();
+
+ /* updateCurrImage does the status-bar cleanup */
+ if( doUpdate )
+ updateCurrImage( resImg );
+ else
+ emit(signalCleanStatusbar());
+ }
+
+}
+
+
+
+void KookaView::slMirrorImage( MirrorType m )
+{
+ const QImage *img = img_canvas->rootImage();
+ bool doUpdate = true;
+
+ if( img )
+ {
+ QImage resImg;
+
+ QApplication::setOverrideCursor(waitCursor);
+ switch( m )
+ {
+ case MirrorVertical:
+ emit( signalChangeStatusbar( i18n("Mirroring image vertically" )));
+ resImg = img->mirror();
+ break;
+ case MirrorHorizontal:
+ emit( signalChangeStatusbar( i18n("Mirroring image horizontally" )));
+ resImg = img->mirror( true, false );
+ break;
+ case MirrorBoth:
+ emit( signalChangeStatusbar( i18n("Mirroring image in both directions" )));
+ resImg = img->mirror( true, true );
+ break;
+ default:
+ kdDebug(28000) << "Mirroring: no way ;)" << endl;
+ doUpdate = false;
+ }
+ QApplication::restoreOverrideCursor();
+
+ /* updateCurrImage does the status-bar cleanup */
+ if( doUpdate )
+ updateCurrImage( resImg );
+ else
+ emit(signalCleanStatusbar());
+
+ // img_canvas->newImage( );
+ }
+}
+
+
+void KookaView::slSaveOCRResult()
+{
+ if( ! m_ocrResEdit ) return;
+ m_ocrResEdit->slSaveText();
+
+}
+
+
+void KookaView::slLoadScanParams( )
+{
+ if( ! sane ) return;
+#if 0
+ /* not yet cooked */
+ LoadSetDialog loadDialog( m_mainDock, sane->shortScannerName(), sane );
+ if( loadDialog.exec())
+ {
+ kdDebug(28000)<< "Executed successfully" << endl;
+ }
+#endif
+}
+
+void KookaView::slSaveScanParams( )
+{
+ if( !sane ) return;
+
+ /* not yet cooked */
+#if 0
+ KScanOptSet optSet( "SaveSet" );
+
+ sane->getCurrentOptions( &optSet );
+ SaveSetDialog dialog( m_mainDock /* this */ , &optSet );
+ if( dialog.exec())
+ {
+ kdDebug(28000)<< "Executed successfully" << endl;
+ QString name = dialog.paramSetName();
+ QString desc = dialog.paramSetDescription();
+ sane->slSaveScanConfigSet( name, desc );
+ }
+#endif
+}
+
+void KookaView::slShowAImage( KookaImage *img )
+{
+ kdDebug(28000) << "Show new Image" << endl;
+ if( img_canvas )
+ {
+ img_canvas->newImage( img );
+ img_canvas->setReadOnly(false);
+ }
+
+ /* tell ocr about */
+ if( ocrFabric )
+ {
+ ocrFabric->slSetImage( img );
+ }
+
+ /* Status Bar */
+ KStatusBar *statBar = m_mainWindow->statusBar();
+ if( img_canvas )
+ statBar->changeItem( img_canvas->imageInfoString(), StatusImage );
+}
+
+void KookaView::slUnloadAImage( KookaImage * )
+{
+ kdDebug(28000) << "Unloading Image" << endl;
+ if( img_canvas )
+ {
+ img_canvas->newImage( 0L );
+ }
+}
+
+
+void KookaView::slShowThumbnails(KFileTreeViewItem *dirKfi, bool forceRedraw )
+{
+ /* If no item is specified, use the current one */
+ if( ! dirKfi )
+ {
+ /* do on the current visible dir */
+ KFileTreeViewItem *kftvi = packager->currentKFileTreeViewItem();
+ if ( !kftvi )
+ {
+ return;
+ }
+
+ if( kftvi->isDir())
+ {
+ dirKfi = kftvi;
+ }
+ else
+ {
+ kftvi = static_cast<KFileTreeViewItem*>(static_cast<QListViewItem*>(kftvi)->parent());
+ dirKfi = kftvi;
+ forceRedraw = true;
+ packager->setSelected( static_cast<QListViewItem*>(dirKfi), true );
+ }
+ }
+
+ kdDebug(28000) << "Showing thumbs for " << dirKfi->url().prettyURL() << endl;
+
+ /* Only do the new thumbview if the old is on another dir */
+ if( m_thumbview && (forceRedraw || m_thumbview->currentDir() != dirKfi->url()) )
+ {
+ m_thumbview->clear();
+ /* Find a list of child KFileItems */
+ if( forceRedraw ) m_thumbview->readSettings();
+
+ KFileItemList fileItemsList;
+
+ QListViewItem * myChild = dirKfi->firstChild();
+ while( myChild )
+ {
+ fileItemsList.append( static_cast<KFileTreeViewItem*>(myChild)->fileItem());
+ myChild = myChild->nextSibling();
+ }
+
+ m_thumbview->slNewFileItems( fileItemsList );
+ m_thumbview->setCurrentDir( dirKfi->url());
+ // m_thumbview->arrangeItemsInGrid();
+ }
+
+}
+
+/* this slot is called when the user clicks on an image in the packager
+ * and loading of the image starts
+ */
+void KookaView::slStartLoading( const KURL& url )
+{
+ emit( signalChangeStatusbar( i18n("Loading %1" ).arg( url.prettyURL() ) ));
+
+ // if( m_stack->visibleWidget() != img_canvas )
+ // {
+ // m_stack->raiseWidget( img_canvas );
+ // }
+
+}
+
+
+void KookaView::updateCurrImage( QImage& img )
+{
+ if( ! img_canvas->readOnly() )
+ {
+ emit( signalChangeStatusbar( i18n("Storing image changes" )));
+ packager->slotCurrentImageChanged( &img );
+ emit( signalCleanStatusbar());
+ }
+ else
+ {
+ emit( signalChangeStatusbar( i18n("Can not save image, it is write protected!")));
+ kdDebug(28000) << "Image is write protected, no saving!" << endl;
+ }
+}
+
+
+void KookaView::saveProperties(KConfig *config)
+{
+ kdDebug(28000) << "Saving Properties for KookaView !" << endl;
+ config->setGroup( GROUP_STARTUP );
+ /* Get with path */
+ config->writePathEntry( STARTUP_IMG_SELECTION, packager->getCurrImageFileName(true));
+
+}
+
+
+void KookaView::slOpenCurrInGraphApp( void )
+{
+ QString file;
+
+ if( packager )
+ {
+ KFileTreeViewItem *ftvi = packager->currentKFileTreeViewItem();
+
+ if( ! ftvi ) return;
+
+ kdDebug(28000) << "Trying to open <" << ftvi->url().prettyURL()<< ">" << endl;
+ KURL::List urllist;
+
+ urllist.append( ftvi->url());
+
+ KRun::displayOpenWithDialog( urllist );
+ }
+}
+
+
+QImage KookaView::rotateLeft( QImage *m_img )
+{
+ QImage rot;
+
+ if( m_img )
+ {
+ QWMatrix m;
+
+ m.rotate(-90);
+ rot = m_img->xForm(m);
+ }
+ return( rot );
+}
+
+QImage KookaView::rotateRight( QImage *m_img )
+{
+ QImage rot;
+
+ if( m_img )
+ {
+ QWMatrix m;
+
+ m.rotate(+90);
+ rot = m_img->xForm(m);
+ }
+ return( rot );
+}
+
+QImage KookaView::rotate180( QImage *m_img )
+{
+ QImage rot;
+
+ if( m_img )
+ {
+ QWMatrix m;
+
+ m.rotate(+180);
+ rot = m_img->xForm(m);
+ }
+ return( rot );
+}
+
+
+
+void KookaView::connectViewerAction( KAction *action )
+{
+ QPopupMenu *popup = img_canvas->contextMenu();
+ kdDebug(29000) << "This is the popup: " << popup << endl;
+ if( popup && action )
+ {
+ action->plug( popup );
+ }
+}
+
+void KookaView::connectGalleryAction( KAction *action )
+{
+ QPopupMenu *popup = packager->contextMenu();
+
+ if( popup && action )
+ {
+ action->plug( popup );
+ }
+}
+
+void KookaView::slFreshUpThumbView()
+{
+ if( m_thumbview )
+ {
+ /* readSettings returns true if something changes */
+ if( m_thumbview->readSettings() )
+ {
+ kdDebug(28000) << "Thumbview-Settings changed, readraw thumbs" << endl;
+ /* new settings */
+ slShowThumbnails(0, true);
+ }
+ }
+}
+
+void KookaView::createDockMenu( KActionCollection *col, KDockMainWindow *mainWin, const char * name )
+{
+ KActionMenu *actionMenu = new KActionMenu( i18n("Tool Views"), "view_icon", col, name );
+
+ actionMenu->insert( new dwMenuAction( i18n("Show Image Viewer"),
+ KShortcut(), m_mainDock, col,
+ mainWin, "dock_viewer" ));
+
+ actionMenu->insert( new dwMenuAction( i18n("Show Preview"),
+ KShortcut(), m_dockPreview, col,
+ mainWin, "dock_preview" ));
+
+ actionMenu->insert( new dwMenuAction( i18n("Show Recent Gallery Folders"),
+ KShortcut(), m_dockRecent, col,
+ mainWin, "dock_recent" ));
+ actionMenu->insert( new dwMenuAction( i18n("Show Gallery"),
+ KShortcut(), m_dockPackager, col,
+ mainWin, "dock_gallery" ));
+
+ actionMenu->insert( new dwMenuAction( i18n("Show Thumbnail Window"),
+ KShortcut(), m_dockThumbs, col,
+ mainWin, "dock_thumbs" ));
+
+ actionMenu->insert( new dwMenuAction( i18n("Show Scan Parameters"),
+ KShortcut(), m_dockScanParam, col,
+ mainWin, "dock_scanparams" ));
+
+ actionMenu->insert( new dwMenuAction( i18n("Show OCR Results"),
+ KShortcut(), m_dockOCRText, col,
+ mainWin, "dock_ocrResults" ));
+}
+
+
+#include "kookaview.moc"