krita

kis_view.cc

00001 /* This file is part of KimageShop^WKrayon^WKrita
00002  *
00003  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
00004  *                1999 Michael Koch    <koch@kde.org>
00005  *                1999 Carsten Pfeiffer <pfeiffer@kde.org>
00006  *                2002 Patrick Julien <freak@codepimps.org>
00007  *                2003-2005 Boudewijn Rempt <boud@valdyas.org>
00008  *                2004 Clarence Dang <dang@kde.org>
00009  *
00010  *  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version.
00014  *
00015  *  This program is distributed in the hope that it will be useful,
00016  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  *  GNU General Public License for more details.
00019  *
00020  *  You should have received a copy of the GNU General Public License
00021  *  along with this program; if not, write to the Free Software
00022  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00023  */
00024 
00025 #include <algorithm>
00026 #include <cmath>
00027 
00028 // Qt
00029 #include <qapplication.h>
00030 #include <qbutton.h>
00031 #include <qcursor.h>
00032 #include <qevent.h>
00033 #include <qpainter.h>
00034 #include <qscrollbar.h>
00035 #include <qspinbox.h>
00036 #include <qdockarea.h>
00037 #include <qstringlist.h>
00038 #include <qstyle.h>
00039 #include <qpopupmenu.h>
00040 #include <qvaluelist.h>
00041 #include <qstringlist.h>
00042 #include <qobjectlist.h>
00043 
00044 // KDE
00045 #include <kis_meta_registry.h>
00046 #include <kglobalsettings.h>
00047 #include <dcopobject.h>
00048 #include <kaction.h>
00049 #include <kcolordialog.h>
00050 #include <kiconloader.h>
00051 #include <kfiledialog.h>
00052 #include <klocale.h>
00053 #include <kmessagebox.h>
00054 #include <knotifyclient.h>
00055 #include <kprinter.h>
00056 #include <kpushbutton.h>
00057 #include <kstatusbar.h>
00058 #include <kstdaction.h>
00059 #include <kinputdialog.h>
00060 #include <kurldrag.h>
00061 #include <kpopupmenu.h>
00062 #include <kdebug.h>
00063 #include <ksharedptr.h>
00064 #include <ktoolbar.h>
00065 #include <kparts/plugin.h>
00066 #include <kservice.h>
00067 #include <ktrader.h>
00068 #include <kparts/componentfactory.h>
00069 #include <kparts/event.h>
00070 
00071 // KOffice
00072 #include <KoPartSelectAction.h>
00073 #include <KoFilterManager.h>
00074 #include <KoMainWindow.h>
00075 #include <KoView.h>
00076 #include <KoTabBar.h>
00077 #include <ko_gray_widget.h>
00078 #include <ko_hsv_widget.h>
00079 #include <ko_rgb_widget.h>
00080 #include <kopalettemanager.h>
00081 #include <kopalette.h>
00082 
00083 // Local
00084 #include "kis_brush.h"
00085 #include "kis_button_press_event.h"
00086 #include "kis_button_release_event.h"
00087 #include "kis_canvas.h"
00088 #include "kis_canvas_painter.h"
00089 #include "kis_color.h"
00090 #include "kis_colorspace_factory_registry.h"
00091 #include "kis_config.h"
00092 #include "kis_controlframe.h"
00093 #include "kis_cursor.h"
00094 #include "kis_doc.h"
00095 #include "kis_double_click_event.h"
00096 #include "kis_factory.h"
00097 #include "kis_filter_strategy.h"
00098 #include "kis_gradient.h"
00099 #include "kis_group_layer.h"
00100 #include "kis_adjustment_layer.h"
00101 #include "kis_paint_device.h"
00102 #include "kis_tool_freehand.h"
00103 //#include "kis_guide.h"
00104 #include "kis_layerbox.h"
00105 #include "kis_import_catcher.h"
00106 #include "kis_layer.h"
00107 #include "kis_paint_layer.h"
00108 #include "kis_move_event.h"
00109 #include "kis_paint_device.h"
00110 #include "kis_painter.h"
00111 #include "kis_paintop_registry.h"
00112 #include "kis_part_layer.h"
00113 #include "kis_part_layer_handler.h"
00114 #include "kis_pattern.h"
00115 #include "kis_profile.h"
00116 #include "kis_rect.h"
00117 #include "kis_resource.h"
00118 #include "kis_palette.h"
00119 #include "kis_ruler.h"
00120 #include "kis_selection.h"
00121 #include "KoToolBox.h"
00122 #include "kis_tool.h"
00123 #include "kis_tool_manager.h"
00124 #include "kis_transaction.h"
00125 #include "kis_selected_transaction.h"
00126 #include "kis_types.h"
00127 #include "kis_undo_adapter.h"
00128 #include "kis_view.h"
00129 #include "kis_view_iface.h"
00130 #include "kis_label_progress.h"
00131 #include "kis_opengl_image_context.h"
00132 #include "kis_background.h"
00133 #include "kis_paint_device_action.h"
00134 #include "kis_filter_configuration.h"
00135 #include "kis_transform_worker.h"
00136 #include "kis_shear_visitor.h"
00137 
00138 #include <kis_resourceserver.h>
00139 #include <kis_resource_mediator.h>
00140 
00141 #include "kis_icon_item.h"
00142 #include "kis_palette_widget.h"
00143 #include "kis_birdeye_box.h"
00144 #include "kis_color.h"
00145 #include "kis_factory.h"
00146 
00147 // Dialog boxes
00148 #include "kis_dlg_new_layer.h"
00149 #include "kis_dlg_layer_properties.h"
00150 #include "kis_dlg_preferences.h"
00151 #include "kis_dlg_image_properties.h"
00152 #include "kis_dlg_adjustment_layer.h"
00153 #include "kis_dlg_adj_layer_props.h"
00154 
00155 // Action managers
00156 #include "kis_selection_manager.h"
00157 #include "kis_filter_manager.h"
00158 #include "kis_grid_manager.h"
00159 #include "kis_perspective_grid_manager.h"
00160 
00161 #include "kis_custom_palette.h"
00162 #include "wdgpalettechooser.h"
00163 
00164 #include <fixx11h.h>
00165 
00166 // Time in ms that must pass after a tablet event before a mouse event is allowed to
00167 // change the input device to the mouse. This is needed because mouse events are always
00168 // sent to a receiver if it does not accept the tablet event.
00169 #define MOUSE_CHANGE_EVENT_DELAY 100
00170 
00171 KisView::KisView(KisDoc *doc, KisUndoAdapter *adapter, QWidget *parent, const char *name)
00172     : super(doc, parent, name)
00173     , KXMLGUIBuilder( shell() )
00174     , m_panning( false )
00175     , m_oldTool( 0 )
00176     , m_doc( doc )
00177     , m_canvas( 0 )
00178     , m_partHandler( 0 )
00179     , m_gridManager( 0 )
00180     , m_perspectiveGridManager( 0 )
00181     , m_selectionManager( 0 )
00182     , m_filterManager( 0 )
00183     , m_paletteManager( 0 )
00184     , m_toolManager( 0 )
00185     , m_actLayerVis( false )
00186     , m_hRuler( 0 )
00187     , m_vRuler( 0 )
00188     , m_imgFlatten( 0 )
00189     , m_imgMergeLayer( 0 )
00190     , m_imgRename( 0 )
00191     , m_imgResizeToLayer( 0 )
00192     , m_imgScan( 0 )
00193     , m_actionPartLayer( 0 )
00194     , m_layerAdd( 0 )
00195     , m_layerBottom( 0 )
00196     , m_layerDup( 0 )
00197     , m_layerHide( 0 )
00198     , m_layerLower( 0 )
00199     , m_layerProperties( 0 )
00200     , m_layerRaise( 0 )
00201     , m_layerRm( 0 )
00202     , m_layerSaveAs( 0 )
00203     , m_layerTop( 0 )
00204     , m_zoomIn( 0 )
00205     , m_zoomOut( 0 )
00206     , m_actualPixels( 0 )
00207     , m_actualSize( 0 )
00208     , m_fitToCanvas( 0 )
00209     , m_fullScreen( 0 )
00210     , m_imgProperties( 0 )
00211     , m_RulerAction( 0 )
00212     , m_guideAction( 0 )
00213     , m_dcop( 0 )
00214     , m_hScroll( 0 )
00215     , m_vScroll( 0 )
00216     , m_scrollX( 0 )
00217     , m_scrollY( 0 )
00218     , m_canvasXOffset( 0)
00219     , m_canvasYOffset( 0)
00220     , m_paintViewEnabled( false )
00221     , m_guiActivateEventReceived( false )
00222     , m_showEventReceived( false )
00223     , m_imageLoaded( false )
00224 //    , m_currentGuide( 0 )
00225     , m_adapter( adapter )
00226     , m_statusBarZoomLabel( 0 )
00227     , m_statusBarSelectionLabel( 0 )
00228     , m_statusBarProfileLabel( 0 )
00229     , m_progress( 0 )
00230     , m_layerBox( 0 )
00231     , m_toolBox( 0 )
00232     , m_brush( 0 )
00233     , m_pattern( 0 )
00234     , m_gradient( 0 )
00235     , m_toolIsPainting( false )
00236     , m_monitorProfile( 0 )
00237     , m_HDRExposure( 0 )
00238 {
00239 
00240     Q_ASSERT(doc);
00241     Q_ASSERT(adapter);
00242     Q_ASSERT(parent);
00243 
00244     KisConfig cfg;
00245 
00246     m_currentColorChooserDisplay = KisID("BLA");
00247     setFocusPolicy( QWidget::StrongFocus );
00248 
00249     // Must come before input devices are referenced as this detects them.
00250 #ifdef Q_WS_X11
00251     KisCanvasWidget::initX11Support();
00252 #endif
00253     // Install event filter before we create any child widgets so they can see
00254     // the tablet events.
00255     qApp->installEventFilter(this);
00256 
00257     m_tabletEventTimer.start();
00258     m_inputDevice = KisInputDevice::mouse();
00259 
00260     connect(&m_initialZoomTimer, SIGNAL(timeout()), SLOT(slotInitialZoomTimeout()));
00261 
00262     m_paletteManager = new KoPaletteManager(this, actionCollection(), "Krita palette manager");
00263     if (cfg.fixDockerWidth()) m_paletteManager->setFixedWidth( 360 );
00264 
00265     m_paletteManager->createPalette( krita::CONTROL_PALETTE, i18n("Control box"));
00266     m_paletteManager->createPalette( krita::COLORBOX, i18n("Colors"));
00267     m_paletteManager->createPalette( krita::LAYERBOX, i18n("Layers"));
00268 
00269     m_selectionManager = new KisSelectionManager(this, doc);
00270     m_filterManager = new KisFilterManager(this, doc);
00271     m_toolManager = new KisToolManager(canvasSubject(), getCanvasController());
00272     m_gridManager = new KisGridManager(this);
00273     m_perspectiveGridManager = new KisPerspectiveGridManager(this);
00274 
00275     // This needs to be set before the dockers are created.
00276     m_image = m_doc->currentImage();
00277     KisColorSpace * cs = KisMetaRegistry::instance()->csRegistry()->getRGB8();
00278     m_fg = KisColor(Qt::black, cs);
00279     m_bg = KisColor(Qt::white, cs);
00280 
00281     createDockers();
00282 
00283     setInstance(KisFactory::instance(), false);
00284     setClientBuilder( this );
00285 
00286     if (!doc->isReadWrite())
00287         setXMLFile("krita_readonly.rc");
00288     else
00289         setXMLFile("krita.rc");
00290 
00291     KStdAction::keyBindings( mainWindow()->guiFactory(), SLOT( configureShortcuts() ), actionCollection() );
00292 
00293     createLayerBox();
00294 
00295     setupCanvas();
00296     m_canvas->hide();
00297     setupRulers();
00298     setupScrollBars();
00299     setupStatusBar();
00300 
00301     setupActions();
00302     dcopObject();
00303 
00304 
00305     connect(this, SIGNAL(autoScroll(const QPoint &)), SLOT(slotAutoScroll(const QPoint &)));
00306 
00307     setMouseTracking(true);
00308 
00309     resetMonitorProfile();
00310 
00311     layersUpdated();
00312 
00313     m_brushesAndStuffToolBar = new KisControlFrame(mainWindow(), this);
00314 
00315     // Load all plugins
00316     KTrader::OfferList offers = KTrader::self()->query(QString::fromLatin1("Krita/ViewPlugin"),
00317                                                          QString::fromLatin1("(Type == 'Service') and "
00318                                                                              "([X-Krita-Version] == 2)"));
00319     KTrader::OfferList::ConstIterator iter;
00320     for(iter = offers.begin(); iter != offers.end(); ++iter)
00321     {
00322         KService::Ptr service = *iter;
00323         int errCode = 0;
00324         KParts::Plugin* plugin =
00325              KParts::ComponentFactory::createInstanceFromService<KParts::Plugin> ( service, this, 0, QStringList(), &errCode);
00326         if ( plugin ) {
00327             kdDebug(41006) << "found plugin " << service->property("Name").toString() << "\n";
00328             insertChildClient(plugin);
00329         }
00330         else {
00331             kdDebug(41006) << "found plugin " << service->property("Name").toString() << ", " << errCode << "\n";
00332         if( errCode == KParts::ComponentFactory::ErrNoLibrary)
00333         {
00334         kdWarning(41006) << " Error loading plugin was : ErrNoLibrary " << KLibLoader::self()->lastErrorMessage() << endl;
00335         }
00336         }
00337     }
00338 
00339     if(!doc->isLoading())
00340     {
00341         slotLoadingFinished();
00342     } else {
00343         connect(doc, SIGNAL(loadingFinished()), this, SLOT(slotLoadingFinished()));
00344     }
00345 
00346     setFocus();
00347 }
00348 
00349 KisView::~KisView()
00350 {
00351     KisConfig cfg;
00352     cfg.setShowRulers( m_RulerAction->isChecked() );
00353 
00354     delete m_dcop;
00355     delete m_paletteManager;
00356     delete m_selectionManager;
00357     delete m_filterManager;
00358     delete m_toolManager;
00359 
00360 }
00361 
00362 
00363 static Qt::Dock stringToDock( const QString& attrPosition )
00364 {
00365     KToolBar::Dock dock = KToolBar::DockTop;
00366     if ( !attrPosition.isEmpty() ) {
00367         if ( attrPosition == "top" )
00368             dock = Qt::DockTop;
00369         else if ( attrPosition == "left" )
00370             dock = Qt::DockLeft;
00371         else if ( attrPosition == "right" )
00372             dock = Qt::DockRight;
00373         else if ( attrPosition == "bottom" )
00374             dock = Qt::DockBottom;
00375         else if ( attrPosition == "floating" )
00376             dock = Qt::DockTornOff;
00377         else if ( attrPosition == "flat" )
00378             dock = Qt::DockMinimized;
00379     }
00380     return dock;
00381 }
00382 
00383 QWidget * KisView::createContainer( QWidget *parent, int index, const QDomElement &element, int &id )
00384 {
00385     if( element.attribute( "name" ) == "ToolBox" )
00386     {
00387         m_toolBox = new KoToolBox(mainWindow(), "ToolBox", KisFactory::instance(), NUMBER_OF_TOOLTYPES);
00388         m_toolBox->setLabel(i18n("Krita"));
00389         m_toolManager->setUp(m_toolBox, m_paletteManager, actionCollection());
00390 
00391         Dock dock = stringToDock( element.attribute( "position" ).lower() );
00392 
00393         mainWindow()->addDockWindow( m_toolBox, dock, false);
00394         mainWindow()->moveDockWindow( m_toolBox, dock, false, 0, 0 );
00395     }
00396 
00397     return KXMLGUIBuilder::createContainer( parent, index, element, id );
00398 
00399 }
00400 
00401 void KisView::removeContainer( QWidget *container, QWidget *parent, QDomElement &element, int id )
00402 {
00403     Q_ASSERT(container);
00404 
00405     if( shell() && container == m_toolBox )
00406     {
00407         delete m_toolBox;
00408         m_toolManager->youAintGotNoToolBox();
00409     }
00410     else {
00411         KXMLGUIBuilder::removeContainer( container, parent, element, id );
00412     }
00413 }
00414 
00415 KoPaletteManager * KisView::paletteManager()
00416 {
00417     if (!m_paletteManager) {
00418         m_paletteManager = new KoPaletteManager(this, actionCollection(), "Krita palette manager");
00419         Q_CHECK_PTR(m_paletteManager);
00420     }
00421     return m_paletteManager;
00422 }
00423 
00424 void KisView::createLayerBox()
00425 {
00426     m_layerBox = new KisLayerBox(this);
00427     m_layerBox->setCaption(i18n("Layers"));
00428 
00429     connect(m_layerBox, SIGNAL(sigRequestLayer(KisGroupLayerSP, KisLayerSP)),
00430             this, SLOT(addLayer(KisGroupLayerSP, KisLayerSP)));
00431     connect(m_layerBox, SIGNAL(sigRequestGroupLayer(KisGroupLayerSP, KisLayerSP)),
00432             this, SLOT(addGroupLayer(KisGroupLayerSP, KisLayerSP)));
00433     connect(m_layerBox, SIGNAL(sigRequestAdjustmentLayer(KisGroupLayerSP, KisLayerSP)),
00434             this, SLOT(addAdjustmentLayer(KisGroupLayerSP, KisLayerSP)));
00435     connect(m_layerBox, SIGNAL(sigRequestPartLayer(KisGroupLayerSP, KisLayerSP, const KoDocumentEntry&)),
00436             this, SLOT(addPartLayer(KisGroupLayerSP, KisLayerSP, const KoDocumentEntry&)));
00437     connect(m_layerBox, SIGNAL(sigRequestLayerProperties(KisLayerSP)),
00438             this, SLOT(showLayerProperties(KisLayerSP)));
00439     connect(m_layerBox, SIGNAL(sigOpacityChanged(int, bool)), this, SLOT(layerOpacity(int, bool)));
00440     connect(m_layerBox, SIGNAL(sigOpacityFinishedChanging(int, int)),
00441             this, SLOT(layerOpacityFinishedChanging(int, int)));
00442     connect(m_layerBox, SIGNAL(sigItemComposite(const KisCompositeOp&)), this, SLOT(layerCompositeOp(const KisCompositeOp&)));
00443 
00444     paletteManager()->addWidget(m_layerBox, "layerbox", krita::LAYERBOX, 0);
00445 
00446 }
00447 
00448 DCOPObject* KisView::dcopObject()
00449 {
00450     if (!m_dcop) {
00451         m_dcop = new KisViewIface(this);
00452         Q_CHECK_PTR(m_dcop);
00453     }
00454     return m_dcop;
00455 }
00456 
00457 void KisView::setupScrollBars()
00458 {
00459     m_scrollX = 0;
00460     m_scrollY = 0;
00461     m_vScroll = new QScrollBar(QScrollBar::Vertical, this);
00462     Q_CHECK_PTR(m_vScroll);
00463 
00464     m_hScroll = new QScrollBar(QScrollBar::Horizontal, this);
00465     Q_CHECK_PTR(m_hScroll);
00466 
00467     m_vScroll->setGeometry(width() - 16, 20, 16, height() - 36);
00468     m_hScroll->setGeometry(20, height() - 16, width() - 36, 16);
00469     m_hScroll->setValue(0);
00470     m_vScroll->setValue(0);
00471     QObject::connect(m_vScroll, SIGNAL(valueChanged(int)), this, SLOT(scrollV(int)));
00472     QObject::connect(m_hScroll, SIGNAL(valueChanged(int)), this, SLOT(scrollH(int)));
00473 }
00474 
00475 void KisView::setupRulers()
00476 {
00477     m_hRuler = new KisRuler(Qt::Horizontal, this);
00478     Q_CHECK_PTR(m_hRuler);
00479 
00480     m_vRuler = new KisRuler(Qt::Vertical, this);
00481     Q_CHECK_PTR(m_vRuler);
00482 
00483     m_hRuler->setGeometry(20, 0, width() - 20, 20);
00484     m_vRuler->setGeometry(0, 20, 20, height() - 20);
00485 
00486     if (statusBar()) {
00487         m_hRuler->installEventFilter(this);
00488         m_vRuler->installEventFilter(this);
00489     }
00490 }
00491 
00492 #define EPSILON 1e-6
00493 
00494 void KisView::updateStatusBarZoomLabel ()
00495 {
00496     if (zoom() < 1 - EPSILON) {
00497         m_statusBarZoomLabel->setText(i18n("Zoom %1%").arg(zoom() * 100, 0, 'g', 4));
00498     } else {
00499         m_statusBarZoomLabel->setText(i18n("Zoom %1%").arg(zoom() * 100, 0, 'f', 0));
00500     }
00501     m_statusBarZoomLabel->setMaximumWidth(m_statusBarZoomLabel->fontMetrics().width(i18n("Zoom %1%").arg("0.8888  ")));
00502 }
00503 
00504 void KisView::updateStatusBarSelectionLabel()
00505 {
00506     if (m_statusBarSelectionLabel == 0) {
00507         return;
00508     }
00509 
00510     KisImageSP img = currentImg();
00511     if (img) {
00512         KisPaintDeviceSP dev = img->activeDevice();
00513         if (dev) {
00514             if (dev->hasSelection()) {
00515                 QRect r = dev->selection()->selectedExactRect();
00516                 m_statusBarSelectionLabel->setText( i18n("Selection Active: x = %1 y = %2 width = %3 height = %4").arg(r.x()).arg(r.y()).arg( r.width()).arg( r.height()));
00517                 return;
00518             }
00519         }
00520     }
00521 
00522     m_statusBarSelectionLabel->setText(i18n("No Selection"));
00523 }
00524 
00525 void KisView::updateStatusBarProfileLabel()
00526 {
00527     if (m_statusBarProfileLabel == 0) {
00528         return;
00529     }
00530 
00531     KisImageSP img = currentImg();
00532     if (!img) return;
00533 
00534     if (img->getProfile() == 0) {
00535         m_statusBarProfileLabel->setText(i18n("No profile"));
00536     }
00537     else {
00538         m_statusBarProfileLabel->setText(img->colorSpace()->id().name() + "  " + img->getProfile()->productName());
00539     }
00540 }
00541 
00542 
00543 KisProfile *  KisView::monitorProfile()
00544 {
00545     if (m_monitorProfile == 0) {
00546         resetMonitorProfile();
00547     }
00548     return m_monitorProfile;
00549 }
00550 
00551 
00552 void KisView::resetMonitorProfile()
00553 {
00554     m_monitorProfile = KisProfile::getScreenProfile();
00555 
00556     if (m_monitorProfile == 0) {
00557         KisConfig cfg;
00558         QString monitorProfileName = cfg.monitorProfile();
00559         m_monitorProfile = KisMetaRegistry::instance()->csRegistry()->getProfileByName(monitorProfileName);
00560     }
00561 
00562 }
00563 
00564 void KisView::setupStatusBar()
00565 {
00566     KStatusBar *sb = statusBar();
00567 
00568     if (sb) {
00569         m_statusBarZoomLabel = new QLabel(sb);
00570         addStatusBarItem(m_statusBarZoomLabel,1);
00571         updateStatusBarZoomLabel();
00572 
00573         m_statusBarSelectionLabel = new KSqueezedTextLabel(sb);
00574         addStatusBarItem(m_statusBarSelectionLabel,2);
00575         updateStatusBarSelectionLabel();
00576 
00577         m_statusBarProfileLabel = new KSqueezedTextLabel(sb);
00578         addStatusBarItem(m_statusBarProfileLabel,3);
00579         updateStatusBarProfileLabel();
00580 
00581         //int height = m_statusBarProfileLabel->height();
00582 
00583         m_progress = new KisLabelProgress(this);
00584         m_progress->setMaximumWidth(225);
00585         m_progress->setMinimumWidth(225);
00586         m_progress->setMaximumHeight(fontMetrics().height() );
00587         addStatusBarItem(m_progress, 2, true);
00588 
00589         m_progress->hide();
00590     }
00591 }
00592 
00593 void KisView::setupActions()
00594 {
00595     KisConfig cfg;
00596 
00597     m_selectionManager->setup(actionCollection());
00598     m_filterManager->setup(actionCollection());
00599     m_gridManager->setup(actionCollection());
00600     m_perspectiveGridManager->setup(actionCollection());
00601 
00602 
00603     m_fullScreen = KStdAction::fullScreen( NULL, NULL, actionCollection(), this );
00604     connect( m_fullScreen, SIGNAL( toggled( bool )), this, SLOT( slotUpdateFullScreen( bool )));
00605 
00606     m_imgProperties = new KAction(i18n("Image Properties"), 0, this, SLOT(slotImageProperties()), actionCollection(), "img_properties");
00607     m_imgScan = 0; // How the hell do I get a KAction to the scan plug-in?!?
00608     m_imgResizeToLayer = new KAction(i18n("Resize Image to Size of Current Layer"), 0, this, SLOT(imgResizeToActiveLayer()), actionCollection(), "resizeimgtolayer");
00609 
00610     // view actions
00611     m_zoomIn = KStdAction::zoomIn(this, SLOT(slotZoomIn()), actionCollection(), "zoom_in");
00612     m_zoomOut = KStdAction::zoomOut(this, SLOT(slotZoomOut()), actionCollection(), "zoom_out");
00613     m_actualPixels = new KAction(i18n("Actual Pixels"), "Ctrl+0", this, SLOT(slotActualPixels()), actionCollection(), "actual_pixels");
00614     m_actualSize = KStdAction::actualSize(this, SLOT(slotActualSize()), actionCollection(), "actual_size");
00615     m_actualSize->setEnabled(false);
00616     m_fitToCanvas = KStdAction::fitToPage(this, SLOT(slotFitToCanvas()), actionCollection(), "fit_to_canvas");
00617 
00618     // layer actions
00619     m_layerAdd = new KAction(i18n("&Add..."), "Ctrl+Shift+N", this, SLOT(layerAdd()), actionCollection(), "insert_layer");
00620 
00621     m_actionPartLayer = new KoPartSelectAction( i18n( "&Object Layer" ), "frame_query",
00622                                                     this, SLOT( addPartLayer() ),
00623                                                     actionCollection(), "insert_part_layer" );
00624 
00625 
00626     m_actionAdjustmentLayer = new KAction( i18n( "&Adjustment Layer" ), 0,
00627             this, SLOT( addAdjustmentLayer() ),
00628             actionCollection(), "insert_adjustment_layer" );
00629 
00630 
00631     m_layerRm = new KAction(i18n("&Remove"), 0, this, SLOT(layerRemove()), actionCollection(), "remove_layer");
00632     m_layerDup = new KAction(i18n("Duplicate"), 0, this, SLOT(layerDuplicate()), actionCollection(), "duplicate_layer");
00633     m_layerHide = new KToggleAction(i18n("&Hide"), 0, this, SLOT(layerToggleVisible()), actionCollection(), "hide_layer");
00634     m_layerHide->setCheckedState(KGuiItem(i18n("&Show")));
00635     m_layerHide->setChecked(false);
00636 
00637     m_layerRaise = new KAction(i18n("Raise"), "raise", "Ctrl+]", this, SLOT(layerRaise()), actionCollection(), "raiselayer");
00638     m_layerLower = new KAction(i18n("Lower"), "lower", "Ctrl+[", this, SLOT(layerLower()), actionCollection(), "lowerlayer");
00639     m_layerTop = new KAction(i18n("To Top"), "bring_forward", "Ctrl+Shift+]", this, SLOT(layerFront()), actionCollection(), "toplayer");
00640     m_layerBottom = new KAction(i18n("To Bottom"), "send_backward", "Ctrl+Shift+[", this, SLOT(layerBack()), actionCollection(), "bottomlayer");
00641     m_layerProperties = new KAction(i18n("Properties"), 0, this, SLOT(layerProperties()), actionCollection(), "layer_properties");
00642     (void)new KAction(i18n("I&nsert Image as Layer..."), 0, this, SLOT(slotInsertImageAsLayer()), actionCollection(), "insert_image_as_layer");
00643     m_layerSaveAs = new KAction(i18n("Save Layer as Image..."), "filesave", this, SLOT(saveLayerAsImage()), actionCollection(), "save_layer_as_image");
00644     (void)new KAction(i18n("Flip on &X Axis"), "view_left_right", 0, this, SLOT(mirrorLayerX()), actionCollection(), "mirrorLayerX");
00645     (void)new KAction(i18n("Flip on &Y Axis"), "view_top_bottom", 0, this, SLOT(mirrorLayerY()), actionCollection(), "mirrorLayerY");
00646 
00647     m_createMask = new KAction(i18n("Create Mask"), 0, this,
00648                                SLOT(slotCreateMask()), actionCollection(), "create_mask");
00649     m_maskFromSelection = new KAction(i18n("Mask From Selection"), 0, this,
00650                                       SLOT(slotMaskFromSelection()), actionCollection(),
00651                                       "mask_fromsel");
00652     m_maskToSelection = new KAction(i18n("Mask to Selection"), 0, this,
00653                                SLOT(slotMaskToSelection()), actionCollection(), "mask_tosel");
00654     m_applyMask = new KAction(i18n("Apply Mask"), 0, this, SLOT(slotApplyMask()),
00655                               actionCollection(), "apply_mask");
00656     m_removeMask = new KAction(i18n("Remove Mask"), 0, this,
00657                                SLOT(slotRemoveMask()), actionCollection(), "remove_mask");
00658     m_showMask = new KToggleAction(i18n( "Show Mask" ), 0, this,
00659                                    SLOT(slotShowMask()), actionCollection(), "show_mask");
00660     m_editMask = new KToggleAction(i18n( "Edit Mask" ), 0, this,
00661                                    SLOT(slotEditMask()), actionCollection(), "edit_mask");
00662 
00663     // image actions
00664     m_imgFlatten = new KAction(i18n("&Flatten Image"), "Ctrl+Shift+E", this, SLOT(flattenImage()), actionCollection(), "flatten_image");
00665     m_imgMergeLayer = new KAction(i18n("&Merge with Layer Below"), "Ctrl+E", this, SLOT(mergeLayer()), actionCollection(), "merge_layer");
00666 
00667     // setting actions
00668     KStdAction::preferences(this, SLOT(preferences()), actionCollection(), "preferences");
00669 
00670     m_RulerAction = new KToggleAction( i18n( "Show Rulers" ), "Ctrl+R", this, SLOT( showRuler() ), actionCollection(), "view_ruler" );
00671     m_RulerAction->setChecked(cfg.showRulers());
00672     m_RulerAction->setCheckedState(i18n("Hide Rulers"));
00673     m_RulerAction->setWhatsThis( i18n("The rulers show the horizontal and vertical positions of the mouse on the image "
00674                                       "and can be used to position your mouse at the right place on the canvas. <p>Uncheck this to disable "
00675                                       "the rulers from being displayed." ) );
00676 
00677     //m_guideAction = new KToggleAction( i18n( "Guide Lines" ), 0, this, SLOT( viewGuideLines() ), actionCollection(), "view_guidelines" );
00678 
00679     // Add new palette
00680     new KAction(i18n("Add New Palette..."), 0, this, SLOT(slotAddPalette()),
00681                 actionCollection(), "add_palette");
00682     new KAction(i18n("Edit Palette..."), 0, this, SLOT(slotEditPalette()),
00683                 actionCollection(), "edit_palette");
00684 
00685     // XXX: This triggers a repaint of the image, but way too early
00686     //showRuler();
00687 
00688 }
00689 
00690 void KisView::resizeEvent(QResizeEvent *)
00691 {
00692     if (!m_paintViewEnabled) {
00693         startInitialZoomTimerIfReady();
00694     }
00695 
00696     KisImageSP img = currentImg();
00697     Q_INT32 scrollBarExtent = style().pixelMetric(QStyle::PM_ScrollBarExtent);
00698     Q_INT32 drawH;
00699     Q_INT32 drawW;
00700     Q_INT32 docW;
00701     Q_INT32 docH;
00702 
00703 //    if (img) {
00704 //        KisGuideMgr *mgr = img->guides();
00705 //        mgr->resize(size());
00706 //    }
00707 
00708     docW = static_cast<Q_INT32>(ceil(docWidth() * zoom()));
00709     docH = static_cast<Q_INT32>(ceil(docHeight() * zoom()));
00710 
00711     m_rulerThickness = m_RulerAction->isChecked() ? RULER_THICKNESS : 0;
00712     drawH = height() - m_rulerThickness;
00713     drawW = width() - m_rulerThickness;
00714 
00715     if (drawH < docH) {
00716         // Will need vert scrollbar
00717         drawW -= scrollBarExtent;
00718         if (drawW < docW)
00719             // Will need horiz scrollbar
00720             drawH -= scrollBarExtent;
00721     } else if (drawW < docW) {
00722         // Will need horiz scrollbar
00723         drawH -= scrollBarExtent;
00724         if (drawH < docH)
00725             // Will need vert scrollbar
00726             drawW -= scrollBarExtent;
00727     }
00728 
00729     m_vScroll->setEnabled(docH > drawH);
00730     m_hScroll->setEnabled(docW > drawW);
00731 
00732     if (docH <= drawH && docW <= drawW) {
00733         // we need no scrollbars
00734         m_vScroll->hide();
00735         m_hScroll->hide();
00736         m_vScroll->setValue(0);
00737         m_hScroll->setValue(0);
00738         m_vScrollBarExtent = 0;
00739         m_hScrollBarExtent = 0;
00740     } else if (docH <= drawH) {
00741         // we need a horizontal scrollbar only
00742         m_vScroll->hide();
00743         m_vScroll->setValue(0);
00744         m_hScroll->setRange(0, docW - drawW);
00745         m_hScroll->setGeometry(m_rulerThickness,
00746                      height() - scrollBarExtent,
00747                      width() - m_rulerThickness,
00748                      scrollBarExtent);
00749         m_hScroll->show();
00750         m_hScrollBarExtent = scrollBarExtent;
00751         m_hScrollBarExtent = scrollBarExtent;
00752     } else if(docW <= drawW) {
00753         // we need a vertical scrollbar only
00754         m_hScroll->hide();
00755         m_hScroll->setValue(0);
00756         m_vScroll->setRange(0, docH - drawH);
00757         m_vScroll->setGeometry(width() - scrollBarExtent, m_rulerThickness, scrollBarExtent, height()  - m_rulerThickness);
00758         m_vScroll->show();
00759         m_vScrollBarExtent = scrollBarExtent;
00760     } else {
00761         // we need both scrollbars
00762         m_vScroll->setRange(0, docH - drawH);
00763         m_vScroll->setGeometry(width() - scrollBarExtent,
00764                     m_rulerThickness,
00765                     scrollBarExtent,
00766                     height() -2* m_rulerThickness);
00767         m_hScroll->setRange(0, docW - drawW);
00768         m_hScroll->setGeometry(m_rulerThickness,
00769                      height() - scrollBarExtent,
00770                      width() - 2*m_rulerThickness,
00771                      scrollBarExtent);
00772         m_vScroll->show();
00773         m_hScroll->show();
00774         m_vScrollBarExtent = scrollBarExtent;
00775         m_hScrollBarExtent = scrollBarExtent;
00776     }
00777 
00778     Q_INT32 oldCanvasXOffset = m_canvasXOffset;
00779     Q_INT32 oldCanvasYOffset = m_canvasYOffset;
00780 
00781     if (docW < drawW) {
00782         m_canvasXOffset = (drawW - docW) / 2;
00783     } else {
00784         m_canvasXOffset = 0;
00785     }
00786 
00787     if (docH < drawH) {
00788         m_canvasYOffset = (drawH - docH) / 2;
00789     } else {
00790         m_canvasYOffset = 0;
00791     }
00792 
00793     //Check if rulers are visible
00794     if( m_RulerAction->isChecked() )
00795         m_canvas->setGeometry(m_rulerThickness, m_rulerThickness, drawW, drawH);
00796     else
00797         m_canvas->setGeometry(0, 0, drawW, drawH);
00798     m_canvas->show();
00799 
00800     if (!m_canvas->isOpenGLCanvas()) {
00801 
00802         if (m_canvasPixmap.size() != QSize(drawW, drawH)) {
00803 
00804             Q_INT32 oldCanvasWidth = m_canvasPixmap.width();
00805             Q_INT32 oldCanvasHeight = m_canvasPixmap.height();
00806 
00807             Q_INT32 newCanvasWidth = drawW;
00808             Q_INT32 newCanvasHeight = drawH;
00809 
00810             QRegion exposedRegion = QRect(0, 0, newCanvasWidth, newCanvasHeight);
00811 
00812             // Increase size first so that we can copy the old image area to the new one.
00813             m_canvasPixmap.resize(QMAX(oldCanvasWidth, newCanvasWidth), QMAX(oldCanvasHeight, newCanvasHeight));
00814 
00815             if (!m_canvasPixmap.isNull()) {
00816 
00817                 if (oldCanvasXOffset != m_canvasXOffset || oldCanvasYOffset != m_canvasYOffset) {
00818 
00819                     Q_INT32 srcX;
00820                     Q_INT32 srcY;
00821                     Q_INT32 srcWidth;
00822                     Q_INT32 srcHeight;
00823                     Q_INT32 dstX;
00824                     Q_INT32 dstY;
00825 
00826                     if (oldCanvasXOffset <= m_canvasXOffset) {
00827                         // Move to the right
00828                         srcX = 0;
00829                         dstX = m_canvasXOffset - oldCanvasXOffset;
00830                         srcWidth = oldCanvasWidth;
00831                     } else {
00832                         // Move to the left
00833                         srcX = oldCanvasXOffset - m_canvasXOffset;
00834                         dstX = 0;
00835                         srcWidth = newCanvasWidth;
00836                     }
00837 
00838                     if (oldCanvasYOffset <= m_canvasYOffset) {
00839                         // Move down
00840                         srcY = 0;
00841                         dstY = m_canvasYOffset - oldCanvasYOffset;
00842                         srcHeight = oldCanvasHeight;
00843                     } else {
00844                         // Move up
00845                         srcY = oldCanvasYOffset - m_canvasYOffset;
00846                         dstY = 0;
00847                         srcHeight = newCanvasHeight;
00848                     }
00849 
00850                     bitBlt(&m_canvasPixmap, dstX, dstY, &m_canvasPixmap, srcX, srcY, srcWidth, srcHeight);
00851                     exposedRegion -= QRegion(QRect(dstX, dstY, srcWidth, srcHeight));
00852                 } else {
00853                     exposedRegion -= QRegion(QRect(0, 0, oldCanvasWidth, oldCanvasHeight));
00854                 }
00855             }
00856 
00857             m_canvasPixmap.resize(newCanvasWidth, newCanvasHeight);
00858 
00859             if (!m_canvasPixmap.isNull() && !exposedRegion.isEmpty()) {
00860 
00861                 QMemArray<QRect> rects = exposedRegion.rects();
00862 
00863                 for (unsigned int i = 0; i < rects.count(); i++) {
00864                     QRect r = rects[i];
00865                     updateQPaintDeviceCanvas(viewToWindow(r));
00866                 }
00867             }
00868         }
00869     }
00870 
00871     int fontheight = QFontMetrics(KGlobalSettings::generalFont()).height() * 3;
00872     m_vScroll->setPageStep(drawH);
00873     m_vScroll->setLineStep(fontheight);
00874     m_hScroll->setPageStep(drawW);
00875     m_hScroll->setLineStep(fontheight);
00876 
00877     m_hRuler->setGeometry(m_rulerThickness + m_canvasXOffset, 0, QMIN(docW, drawW), m_rulerThickness);
00878     m_vRuler->setGeometry(0, m_rulerThickness + m_canvasYOffset, m_rulerThickness, QMIN(docH, drawH));
00879 
00880     if (m_vScroll->isVisible())
00881         m_vRuler->updateVisibleArea(0, m_vScroll->value());
00882     else
00883         m_vRuler->updateVisibleArea(0, 0);
00884 
00885     if (m_hScroll->isVisible())
00886         m_hRuler->updateVisibleArea(m_hScroll->value(), 0);
00887     else
00888         m_hRuler->updateVisibleArea(0, 0);
00889 
00890     if( m_RulerAction->isChecked() )
00891     {
00892         m_hRuler->show();
00893         m_vRuler->show();
00894     }
00895     else {
00896         m_hRuler->hide();
00897         m_vRuler->hide();
00898     }
00899 
00900     emit viewTransformationsChanged();
00901 }
00902 
00903 void KisView::styleChange(QStyle& oldStyle)
00904 {
00905     Q_UNUSED(oldStyle);
00906     m_canvas->updateGeometry();
00907     refreshKisCanvas();
00908 }
00909 
00910 void KisView::paletteChange(const QPalette& oldPalette)
00911 {
00912     Q_UNUSED(oldPalette);
00913     refreshKisCanvas();
00914 }
00915 
00916 void KisView::showEvent(QShowEvent *)
00917 {
00918     if (!m_showEventReceived) {
00919         m_showEventReceived = true;
00920         startInitialZoomTimerIfReady();
00921     }
00922 }
00923 
00924 void KisView::updateReadWrite(bool readwrite)
00925 {
00926     layerUpdateGUI(readwrite);
00927 }
00928 
00929 Q_INT32 KisView::horzValue() const
00930 {
00931     return m_hScroll->value() - m_canvasXOffset;
00932 }
00933 
00934 Q_INT32 KisView::vertValue() const
00935 {
00936     return m_vScroll->value() - m_canvasYOffset;
00937 }
00938 
00939 void KisView::updateQPaintDeviceCanvas(const QRect& imageRect)
00940 {
00941     QRect vr = windowToView(imageRect);
00942     vr &= QRect(0, 0, m_canvas->width(), m_canvas->height());
00943 
00944     if (!vr.isEmpty()) {
00945 
00946         QPainter gc;
00947 
00948         if (gc.begin(&m_canvasPixmap)) {
00949 
00950             KisImageSP img = currentImg();
00951 
00952             if (img && m_paintViewEnabled) {
00953 
00954                 QRect wr = viewToWindow(vr);
00955 
00956                 if (wr.left() < 0 || wr.right() >= img->width() || wr.top() < 0 || wr.bottom() >= img->height()) {
00957                     // Erase areas outside document
00958                     QRegion rg(vr);
00959                     rg -= QRegion(windowToView(QRect(0, 0, img->width(), img->height())));
00960 
00961                     QMemArray<QRect> rects = rg.rects();
00962 
00963                     for (unsigned int i = 0; i < rects.count(); i++) {
00964                         QRect er = rects[i];
00965                         gc.fillRect(er, colorGroup().mid());
00966                     }
00967                     wr &= QRect(0, 0, img->width(), img->height());
00968                 }
00969 
00970                 if (!wr.isEmpty()) {
00971 
00972                     KisImage::PaintFlags paintFlags = (KisImage::PaintFlags)KisImage::PAINT_BACKGROUND;
00973 
00974                     if (m_actLayerVis) {
00975                         paintFlags = (KisImage::PaintFlags)(paintFlags|KisImage::PAINT_MASKINACTIVELAYERS);
00976                     }
00977 
00978                     if (m_selectionManager->displaySelection())
00979                     {
00980                         paintFlags = (KisImage::PaintFlags)(paintFlags|KisImage::PAINT_SELECTION);
00981                     }
00982 
00983                     if (zoom() > 1.0 - EPSILON) {
00984 
00985                         gc.setWorldXForm(true);
00986                         gc.translate(-horzValue(), -vertValue());
00987                         gc.scale(zoomFactor(), zoomFactor());
00988 
00989                         m_image->renderToPainter(wr.left(), wr.top(),
00990                             wr.right(), wr.bottom(), gc, monitorProfile(),
00991                             paintFlags, HDRExposure());
00992                     } else {
00993 
00994                         QRect canvasRect = windowToView(wr);
00995                         QRect scaledImageRect = canvasRect;
00996                         scaledImageRect.moveBy(horzValue(), vertValue());
00997 
00998                         QSize scaledImageSize(static_cast<Q_INT32>(ceil(docWidth() * zoom())),
00999                                             static_cast<Q_INT32>(ceil(docHeight() * zoom())));
01000 
01001                         QImage image = m_image->convertToQImage(scaledImageRect, scaledImageSize,
01002                                                                 monitorProfile(), paintFlags, HDRExposure());
01003 
01004                         gc.drawImage(canvasRect.topLeft(), image, image.rect());
01005 
01006                         // Set up for the grid drawer.
01007                         gc.setWorldXForm(true);
01008                         gc.translate(-horzValue(), -vertValue());
01009                         gc.scale(zoomFactor(), zoomFactor());
01010                     }
01011 
01012                     m_gridManager->drawGrid( wr, &gc );
01013                     m_perspectiveGridManager->drawGrid( wr, &gc );
01014                 }
01015 //                    paintGuides();
01016             } else {
01017                 gc.fillRect(vr, colorGroup().mid());
01018             }
01019         }
01020     }
01021 }
01022 
01023 void KisView::paintQPaintDeviceView(const QRegion& canvasRegion)
01024 {
01025     Q_ASSERT(m_canvas->QPaintDeviceWidget() != 0);
01026 
01027     if (m_canvas->QPaintDeviceWidget() != 0 && !m_canvasPixmap.isNull()) {
01028         QMemArray<QRect> rects = canvasRegion.rects();
01029 
01030         for (unsigned int i = 0; i < rects.count(); i++) {
01031             QRect r = rects[i];
01032 
01033             bitBlt(m_canvas->QPaintDeviceWidget(), r.x(), r.y(), &m_canvasPixmap,
01034                    r.x(), r.y(), r.width(), r.height());
01035         }
01036 
01037         paintToolOverlay(canvasRegion);
01038     }
01039 }
01040 
01041 void KisView::updateOpenGLCanvas(const QRect& imageRect)
01042 {
01043 #ifdef HAVE_GL
01044     KisImageSP img = currentImg();
01045 
01046     if (img && m_paintViewEnabled) {
01047         Q_ASSERT(m_OpenGLImageContext != 0);
01048 
01049         if (m_OpenGLImageContext != 0) {
01050             m_OpenGLImageContext->update(imageRect);
01051         }
01052     }
01053 #else
01054     Q_UNUSED(imageRect);
01055 #endif
01056 }
01057 
01058 void KisView::paintOpenGLView(const QRect& canvasRect)
01059 {
01060 #ifdef HAVE_GL
01061     if (!m_canvas->isUpdatesEnabled()) {
01062         return;
01063     }
01064 
01065     m_canvas->OpenGLWidget()->makeCurrent();
01066 
01067     glDrawBuffer(GL_BACK);
01068 
01069     QColor widgetBackgroundColor = colorGroup().mid();
01070 
01071     glClearColor(widgetBackgroundColor.red() / 255.0, widgetBackgroundColor.green() / 255.0, widgetBackgroundColor.blue() / 255.0, 1.0);
01072     glClear(GL_COLOR_BUFFER_BIT);
01073 
01074     KisImageSP img = currentImg();
01075 
01076     if (img && m_paintViewEnabled) {
01077 
01078         QRect vr = canvasRect;
01079         vr &= QRect(0, 0, m_canvas->width(), m_canvas->height());
01080 
01081         if (!vr.isNull()) {
01082 
01083             glMatrixMode(GL_PROJECTION);
01084             glLoadIdentity();
01085             glViewport(0, 0, m_canvas->width(), m_canvas->height());
01086             glOrtho(0, m_canvas->width(), m_canvas->height(), 0, -1, 1);
01087 
01088             glMatrixMode(GL_MODELVIEW);
01089             glLoadIdentity();
01090 
01091             glBindTexture(GL_TEXTURE_2D, m_OpenGLImageContext->backgroundTexture());
01092 
01093             glTranslatef(m_canvasXOffset, m_canvasYOffset, 0.0);
01094 
01095             glEnable(GL_TEXTURE_2D);
01096             glBegin(GL_QUADS);
01097 
01098             glTexCoord2f(0.0, 0.0);
01099             glVertex2f(0.0, 0.0);
01100 
01101             glTexCoord2f((img->width() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_WIDTH, 0.0);
01102             glVertex2f(img->width() * zoom(), 0.0);
01103 
01104             glTexCoord2f((img->width() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_WIDTH,
01105                          (img->height() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_HEIGHT);
01106             glVertex2f(img->width() * zoom(), img->height() * zoom());
01107 
01108             glTexCoord2f(0.0, (img->height() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_HEIGHT);
01109             glVertex2f(0.0, img->height() * zoom());
01110 
01111             glEnd();
01112 
01113             glTranslatef(-m_canvasXOffset, -m_canvasYOffset, 0.0);
01114 
01115             glTranslatef(-horzValue(), -vertValue(), 0.0);
01116             glScalef(zoomFactor(), zoomFactor(), 1.0);
01117 
01118             glEnable(GL_BLEND);
01119             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
01120 
01121             QRect wr = viewToWindow(QRect(0, 0, m_canvas->width(), m_canvas->height()));
01122             wr &= QRect(0, 0, img->width(), img->height());
01123 
01124             m_OpenGLImageContext->setHDRExposure(HDRExposure());
01125 
01126             m_canvas->OpenGLWidget()->makeCurrent();
01127 
01128             for (int x = (wr.left() / m_OpenGLImageContext->imageTextureTileWidth()) * m_OpenGLImageContext->imageTextureTileWidth();
01129                   x <= wr.right();
01130                   x += m_OpenGLImageContext->imageTextureTileWidth()) {
01131                 for (int y = (wr.top() / m_OpenGLImageContext->imageTextureTileHeight()) * m_OpenGLImageContext->imageTextureTileHeight();
01132                       y <= wr.bottom();
01133                       y += m_OpenGLImageContext->imageTextureTileHeight()) {
01134 
01135                     glBindTexture(GL_TEXTURE_2D, m_OpenGLImageContext->imageTextureTile(x, y));
01136 
01137                     glBegin(GL_QUADS);
01138 
01139                     glTexCoord2f(0.0, 0.0);
01140                     glVertex2f(x, y);
01141 
01142                     glTexCoord2f(1.0, 0.0);
01143                     glVertex2f(x + m_OpenGLImageContext->imageTextureTileWidth(), y);
01144 
01145                     glTexCoord2f(1.0, 1.0);
01146                     glVertex2f(x + m_OpenGLImageContext->imageTextureTileWidth(), y + m_OpenGLImageContext->imageTextureTileHeight());
01147 
01148                     glTexCoord2f(0.0, 1.0);
01149                     glVertex2f(x, y + m_OpenGLImageContext->imageTextureTileHeight());
01150 
01151                     glEnd();
01152                 }
01153             }
01154 
01155             glDisable(GL_TEXTURE_2D);
01156             glDisable(GL_BLEND);
01157 
01158             m_gridManager->drawGrid(wr, 0, true);
01159             m_perspectiveGridManager->drawGrid( wr, 0, true );
01160 
01161             // Unbind the texture otherwise the ATI driver crashes when the canvas context is
01162             // made current after the textures are deleted following an image resize.
01163             glBindTexture(GL_TEXTURE_2D, 0);
01164 
01165             //paintGuides();
01166         }
01167     }
01168 
01169     m_canvas->OpenGLWidget()->swapBuffers();
01170 
01171     paintToolOverlay(QRegion(canvasRect));
01172 
01173 #else
01174     Q_UNUSED(canvasRect);
01175 #endif
01176 }
01177 
01178 void KisView::setInputDevice(KisInputDevice inputDevice)
01179 {
01180     if (inputDevice != m_inputDevice) {
01181         m_inputDevice = inputDevice;
01182 
01183         m_toolManager->setToolForInputDevice(m_inputDevice, inputDevice);
01184 
01185         if (m_toolManager->currentTool() == 0) {
01186             m_toolManager->setCurrentTool(m_toolManager->findTool("tool_brush", m_inputDevice));
01187         }
01188         else {
01189             m_toolManager->setCurrentTool(m_toolManager->currentTool());
01190         }
01191         m_toolManager->activateCurrentTool();
01192 
01193         emit sigInputDeviceChanged(inputDevice);
01194     }
01195 
01196 }
01197 
01198 KisInputDevice KisView::currentInputDevice() const
01199 {
01200     return m_inputDevice;
01201 }
01202 
01203 
01204 KisCanvas *KisView::kiscanvas() const
01205 {
01206     return m_canvas;
01207 }
01208 
01209 void KisView::updateCanvas()
01210 {
01211     if (m_image) {
01212         updateCanvas(m_image->bounds());
01213     }
01214 }
01215 
01216 void KisView::updateCanvas(Q_INT32 x, Q_INT32 y, Q_INT32 w, Q_INT32 h)
01217 {
01218     updateCanvas(QRect(x, y, w, h));
01219 }
01220 
01221 void KisView::updateCanvas(const QRect& imageRect)
01222 {
01223     if (m_canvas->isOpenGLCanvas()) {
01224         updateOpenGLCanvas(imageRect);
01225         paintOpenGLView(windowToView(imageRect));
01226     } else {
01227         updateQPaintDeviceCanvas(imageRect);
01228         //m_canvas->update(windowToView(imageRect));
01229         m_canvas->repaint(windowToView(imageRect));
01230     }
01231 }
01232 
01233 void KisView::refreshKisCanvas()
01234 {
01235     QRect imageRect = viewToWindow(QRect(0, 0, m_canvas->width(), m_canvas->height()));
01236 
01237     if (m_image) {
01238         imageRect |= m_image->bounds();
01239     }
01240 
01241     updateCanvas(imageRect);
01242 
01243     // Enable this if updateCanvas does an m_canvas->update()
01244     //m_canvas->repaint();
01245 }
01246 
01247 void KisView::selectionDisplayToggled(bool displaySelection)
01248 {
01249 #ifdef HAVE_GL
01250     if (m_canvas->isOpenGLCanvas()) {
01251         if (m_OpenGLImageContext) {
01252             m_OpenGLImageContext->setSelectionDisplayEnabled(displaySelection);
01253         }
01254     }
01255 #else
01256     Q_UNUSED(displaySelection);
01257 #endif
01258     updateCanvas();
01259 }
01260 
01261 void KisView::layerUpdateGUI(bool enable)
01262 {
01263     KisImageSP img = currentImg();
01264 
01265     KisLayerSP layer;
01266     Q_INT32 nlayers = 0;
01267     Q_INT32 nvisible = 0;
01268 
01269 
01270 
01271     if (img) {
01272         layer = img->activeLayer();
01273         nlayers = img->nlayers();
01274         nvisible = nlayers - img->nHiddenLayers();
01275     }
01276 
01277     KisPaintLayer * pl = dynamic_cast<KisPaintLayer*>(layer.data());
01278 
01279     if (pl && ( m_currentColorChooserDisplay != KisID("BLA") ||
01280                 pl->paintDevice()->colorSpace()->id() != m_currentColorChooserDisplay)) {
01281         if (pl->paintDevice()->colorSpace()->id() == KisID("WET")) {
01282             m_paletteManager->hideWidget( "hsvwidget" );
01283             m_paletteManager->hideWidget( "rgbwidget" );
01284             m_paletteManager->hideWidget( "graywidget" );
01285             m_paletteManager->hideWidget( "palettewidget" );
01286             m_paletteManager->showWidget( "watercolor docker" );
01287         }
01288         else {
01289             m_paletteManager->hideWidget( "watercolor docker" );
01290             m_paletteManager->showWidget( "palettewidget" );
01291             m_paletteManager->showWidget( "graywidget" );
01292             m_paletteManager->showWidget( "rgbwidget" );
01293             m_paletteManager->showWidget( "hsvwidget" );
01294         }
01295         m_currentColorChooserDisplay = pl->paintDevice()->colorSpace()->id();
01296     }
01297 
01298     enable = enable && img && layer && layer->visible() && !layer->locked();
01299     m_layerDup->setEnabled(enable);
01300     m_layerRm->setEnabled(enable);
01301     m_layerHide->setEnabled(img && layer);
01302     m_layerProperties->setEnabled(enable);
01303     m_layerSaveAs->setEnabled(enable);
01304     m_layerRaise->setEnabled(enable && layer->prevSibling());
01305     m_layerLower->setEnabled(enable && layer->nextSibling());
01306     m_layerTop->setEnabled(enable && nlayers > 1 && layer != img->rootLayer()->firstChild());
01307     m_layerBottom->setEnabled(enable && nlayers > 1 && layer != img->rootLayer()->lastChild());
01308 
01309     // XXX these should be named layer instead of img
01310     m_imgFlatten->setEnabled(nlayers > 1);
01311     m_imgMergeLayer->setEnabled(nlayers > 1 && layer && layer->nextSibling());
01312 
01313 
01314     m_selectionManager->updateGUI();
01315     m_filterManager->updateGUI();
01316     m_toolManager->updateGUI();
01317     m_gridManager->updateGUI();
01318     m_perspectiveGridManager->updateGUI();
01319 
01320 
01321     KisPartLayer * partLayer = dynamic_cast<KisPartLayer*>(layer.data());
01322     if (partLayer) {
01323         setCanvasCursor( KisCursor::arrowCursor() );
01324     }
01325 
01326     if (img && img->activeDevice())
01327         emit currentColorSpaceChanged(img->activeDevice()->colorSpace());
01328 
01329     imgUpdateGUI();
01330 }
01331 
01332 
01333 void KisView::imgUpdateGUI()
01334 {
01335     KisImageSP img = currentImg();
01336 
01337     m_imgResizeToLayer->setEnabled(img && img->activeLayer());
01338 
01339     updateStatusBarProfileLabel();
01340 }
01341 
01342 static const double zoomLevels[] = {
01343     1.0 / 500,
01344     1.0 / 333.333333,
01345     1.0 / 250,
01346     1.0 / 200,
01347     1.0 / 150,
01348     1.0 / 100,
01349     1.0 / 66.666667,
01350     1.0 / 50,
01351     1.0 / 33.333333,
01352     1.0 / 25,
01353     1.0 / 20,
01354     1.0 / 16,
01355     1.0 / 12,
01356     1.0 / 8,
01357     1.0 / 6,
01358     1.0 / 4,
01359     1.0 / 3,
01360     1.0 / 2,
01361     1.0 / 1.5,
01362     1,
01363     2,
01364     3,
01365     4,
01366     5,
01367     6,
01368     7,
01369     8,
01370     12,
01371     16
01372 };
01373 
01374 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
01375 #define NUM_ZOOM_LEVELS ARRAY_SIZE(zoomLevels)
01376 
01377 #define FIRST_ZOOM_LEVEL_INDEX 0
01378 #define LAST_ZOOM_LEVEL_INDEX (NUM_ZOOM_LEVELS - 1)
01379 
01380 #define KISVIEW_MIN_ZOOM (zoomLevels[FIRST_ZOOM_LEVEL_INDEX])
01381 #define KISVIEW_MAX_ZOOM (zoomLevels[LAST_ZOOM_LEVEL_INDEX])
01382 
01383 double KisView::nextZoomInLevel() const
01384 {
01385     uint zoomLevelIndex = FIRST_ZOOM_LEVEL_INDEX;
01386 
01387     while (zoom() >= zoomLevels[zoomLevelIndex] && zoomLevelIndex < LAST_ZOOM_LEVEL_INDEX) {
01388         zoomLevelIndex++;
01389     }
01390 
01391     return zoomLevels[zoomLevelIndex];
01392 }
01393 
01394 double KisView::nextZoomOutLevel(double zoomLevel) const
01395 {
01396     int zoomLevelIndex = LAST_ZOOM_LEVEL_INDEX;
01397 
01398     while (zoomLevel <= zoomLevels[zoomLevelIndex] && zoomLevelIndex > FIRST_ZOOM_LEVEL_INDEX) {
01399         zoomLevelIndex--;
01400     }
01401 
01402     return zoomLevels[zoomLevelIndex];
01403 }
01404 
01405 double KisView::nextZoomOutLevel() const
01406 {
01407     return nextZoomOutLevel(zoom());
01408 }
01409 
01410 void KisView::zoomAroundPoint(double x, double y, double zf)
01411 {
01412     // Disable updates while we change the scrollbar settings.
01413     m_canvas->setUpdatesEnabled(false);
01414     m_hScroll->setUpdatesEnabled(false);
01415     m_vScroll->setUpdatesEnabled(false);
01416 
01417     if (x < 0 || y < 0) {
01418         // Zoom about the centre of the current display
01419         KisImageSP img = currentImg();
01420 
01421         if (img) {
01422             if (m_hScroll->isVisible()) {
01423                 KisPoint c = viewToWindow(KisPoint(m_canvas->width() / 2.0, m_canvas->height() / 2.0));
01424                 x = c.x();
01425             }
01426             else {
01427                 x = img->width() / 2.0;
01428             }
01429 
01430             if (m_vScroll->isVisible()) {
01431                 KisPoint c = viewToWindow(KisPoint(m_canvas->width() / 2.0, m_canvas->height() / 2.0));
01432                 y = c.y();
01433             }
01434             else {
01435                 y = img->height() / 2.0;
01436             }
01437         }
01438         else {
01439             x = 0;
01440             y = 0;
01441         }
01442     }
01443 
01444     setZoom(zf);
01445 
01446     Q_ASSERT(m_zoomIn);
01447     Q_ASSERT(m_zoomOut);
01448 
01449     updateStatusBarZoomLabel ();
01450 
01451     m_zoomIn->setEnabled(zf < KISVIEW_MAX_ZOOM);
01452     m_zoomOut->setEnabled(zf > KISVIEW_MIN_ZOOM);
01453     resizeEvent(0);
01454 
01455     m_hRuler->setZoom(zf);
01456     m_vRuler->setZoom(zf);
01457 
01458     if (m_hScroll->isVisible()) {
01459         double vcx = m_canvas->width() / 2.0;
01460         Q_INT32 scrollX = qRound(x * zoom() - vcx);
01461         m_hScroll->setValue(scrollX);
01462     }
01463 
01464     if (m_vScroll->isVisible()) {
01465         double vcy = m_canvas->height() / 2.0;
01466         Q_INT32 scrollY = qRound(y * zoom() - vcy);
01467         m_vScroll->setValue(scrollY);
01468     }
01469 
01470     // Now update everything.
01471     m_canvas->setUpdatesEnabled(true);
01472     m_hScroll->setUpdatesEnabled(true);
01473     m_vScroll->setUpdatesEnabled(true);
01474     m_hScroll->update();
01475     m_vScroll->update();
01476 
01477     if (m_canvas->isOpenGLCanvas()) {
01478         paintOpenGLView(QRect(0, 0, m_canvas->width(), m_canvas->height()));
01479     } else {
01480         refreshKisCanvas();
01481     }
01482 
01483     emit viewTransformationsChanged();
01484 }
01485 
01486 void KisView::zoomTo(const KisRect& r)
01487 {
01488     if (!r.isNull()) {
01489 
01490         double wZoom = fabs(m_canvas->width() / r.width());
01491         double hZoom = fabs(m_canvas->height() / r.height());
01492 
01493         double zf = kMin(wZoom, hZoom);
01494 
01495         if (zf < KISVIEW_MIN_ZOOM) {
01496             zf = KISVIEW_MIN_ZOOM;
01497         }
01498         else
01499             if (zf > KISVIEW_MAX_ZOOM) {
01500                 zf = KISVIEW_MAX_ZOOM;
01501             }
01502 
01503         zoomAroundPoint(r.center().x(), r.center().y(), zf);
01504     }
01505 }
01506 
01507 void KisView::zoomTo(const QRect& r)
01508 {
01509     zoomTo(KisRect(r));
01510 }
01511 
01512 void KisView::zoomTo(Q_INT32 x, Q_INT32 y, Q_INT32 w, Q_INT32 h)
01513 {
01514     zoomTo(KisRect(x, y, w, h));
01515 }
01516 
01517 void KisView::zoomIn(Q_INT32 x, Q_INT32 y)
01518 {
01519     zoomAroundPoint(x, y, nextZoomInLevel());
01520 }
01521 
01522 void KisView::zoomOut(Q_INT32 x, Q_INT32 y)
01523 {
01524     zoomAroundPoint(x, y, nextZoomOutLevel());
01525 }
01526 
01527 void KisView::zoomIn()
01528 {
01529     slotZoomIn();
01530 }
01531 
01532 void KisView::zoomOut()
01533 {
01534     slotZoomOut();
01535 }
01536 
01537 void KisView::slotZoomIn()
01538 {
01539     zoomIn(-1, -1);
01540 }
01541 
01542 void KisView::slotZoomOut()
01543 {
01544     zoomOut(-1, -1);
01545 }
01546 
01547 void KisView::slotActualPixels()
01548 {
01549     zoomAroundPoint(-1, -1, 1.0);
01550 }
01551 
01552 void KisView::slotActualSize()
01553 {
01554     //XXX later this should be update to take screen res and image res into consideration
01555     zoomAroundPoint(-1, -1, 1.0);
01556 }
01557 
01558 double KisView::fitToCanvasZoomLevel() const
01559 {
01560     int fullCanvasWidth = width();
01561 
01562     if (m_vRuler->isVisible()) {
01563         fullCanvasWidth -= m_vRuler->width();
01564     }
01565 
01566     int fullCanvasHeight = height();
01567 
01568     if (m_hRuler->isVisible()) {
01569         fullCanvasHeight -= m_hRuler->height();
01570     }
01571 
01572     KisImageSP img = currentImg();
01573     if (img) {
01574         double xZoomLevel = static_cast<double>(fullCanvasWidth) / img->width();
01575         double yZoomLevel = static_cast<double>(fullCanvasHeight) / img->height();
01576 
01577         return QMIN(xZoomLevel, yZoomLevel);
01578     }
01579     else {
01580         return 1;
01581     }
01582 }
01583 
01584 void KisView::slotFitToCanvas()
01585 {
01586     zoomAroundPoint(-1, -1, fitToCanvasZoomLevel());
01587 }
01588 
01589 void KisView::setInitialZoomLevel()
01590 {
01591     double zoomLevel = fitToCanvasZoomLevel();
01592 
01593     if (zoomLevel > 1) {
01594         zoomLevel = 1;
01595     } else {
01596         zoomLevel = nextZoomOutLevel(zoomLevel);
01597     }
01598 
01599     zoomAroundPoint(-1, -1, zoomLevel);
01600 }
01601 
01602 void KisView::imgResizeToActiveLayer()
01603 {
01604     KisImageSP img = currentImg();
01605     KisLayerSP layer;
01606 
01607     if (img && (layer = img->activeLayer())) {
01608 
01609         if (m_adapter && m_adapter->undo()) {
01610             m_adapter->beginMacro(i18n("Resize Image to Size of Current Layer"));
01611         }
01612 
01613         img->lock();
01614 
01615         QRect r = layer->exactBounds();
01616         img->resize(r.width(), r.height(), r.x(), r.y(), true);
01617 
01618         img->unlock();
01619 
01620         if (m_adapter && m_adapter->undo()) {
01621             m_adapter->endMacro();
01622         }
01623     }
01624 }
01625 
01626 void KisView::slotImageProperties()
01627 {
01628     KisImageSP img = currentImg();
01629 
01630     if (!img) return;
01631 
01632     KisDlgImageProperties dlg(img, this);
01633 
01634     if (dlg.exec() == QDialog::Accepted) {
01635         if (dlg.imageWidth() != img->width() ||
01636             dlg.imageHeight() != img->height()) {
01637 
01638             resizeCurrentImage(dlg.imageWidth(),
01639                                dlg.imageHeight());
01640         }
01641         Q_INT32 opacity = dlg.opacity();
01642         opacity = opacity * 255 / 100;
01643         img->setName(dlg.imageName());
01644         img->setColorSpace(dlg.colorSpace());
01645         img->setResolution(dlg.resolution(), dlg.resolution());
01646         img->setDescription(dlg.description());
01647         img->setProfile(dlg.profile());
01648     }
01649 }
01650 
01651 void KisView::slotInsertImageAsLayer()
01652 {
01653     if (importImage() > 0)
01654         m_doc->setModified(true);
01655 }
01656 
01657 void KisView::slotAddPalette()
01658 {
01659     KDialogBase* base = new KDialogBase(this, 0, true, i18n("Add Palette"), KDialogBase::Ok | KDialogBase::Cancel);
01660     KisCustomPalette* p = new KisCustomPalette(base, "add palette", i18n("Add Palette"), this);
01661     base->setMainWidget(p);
01662     base->show();
01663 }
01664 
01665 void KisView::slotEditPalette()
01666 {
01667     KisPaletteChooser chooser(this);
01668     KisResourceServerBase* srv = KisResourceServerRegistry::instance()->get("PaletteServer");
01669     if (!srv) {
01670         return;
01671     }
01672     QValueList<KisResource*> resources = srv->resources();
01673     QValueList<KisPalette*> palettes;
01674 
01675     for(uint i = 0; i < resources.count(); i++) {
01676         KisPalette* palette = dynamic_cast<KisPalette*>(*resources.at(i));
01677 
01678         chooser.paletteList->insertItem(palette->name());
01679         palettes.append(palette);
01680     }
01681 
01682     if (chooser.exec() != QDialog::Accepted ) {
01683         return;
01684     }
01685 
01686     int index = chooser.paletteList->currentItem();
01687     if (index < 0) {
01688         KMessageBox::error(this, i18n("No palette selected."), i18n("Palette"));
01689         return;
01690     }
01691 
01692     KDialogBase* base = new KDialogBase(this, 0, true, i18n("Edit Palette") , KDialogBase::Ok);
01693     KisCustomPalette* cp = new KisCustomPalette(base, "edit palette",
01694             i18n("Edit Palette"), this);
01695     cp->setEditMode(true);
01696     cp->setPalette(*palettes.at(index));
01697     base->setMainWidget(cp);
01698     base->show();
01699 }
01700 
01701 void KisView::saveLayerAsImage()
01702 {
01703     QStringList listMimeFilter = KoFilterManager::mimeFilter("application/x-krita", KoFilterManager::Export);
01704     QString mimelist = listMimeFilter.join(" ");
01705 
01706     KFileDialog fd (QString::null, mimelist, this, "Export Layer", true);
01707     fd.setCaption(i18n("Export Layer"));
01708     fd.setMimeFilter(listMimeFilter);
01709     fd.setOperationMode(KFileDialog::Saving);
01710 
01711     if (!fd.exec()) return;
01712 
01713     KURL url = fd.selectedURL();
01714     QString mimefilter = fd.currentMimeFilter();
01715 
01716     if (url.isEmpty())
01717         return;
01718 
01719 
01720     KisImageSP img = currentImg();
01721     if (!img) return;
01722 
01723     KisLayerSP l = img->activeLayer();
01724     if (!l) return;
01725 
01726     QRect r = l->exactBounds();
01727 
01728     KisDoc d;
01729     d.prepareForImport();
01730 
01731     KisImageSP dst = new KisImage(d.undoAdapter(), r.width(), r.height(), img->colorSpace(), l->name());
01732     d.setCurrentImage( dst );
01733     dst->addLayer(l->clone(),dst->rootLayer(),0);
01734 
01735     d.setOutputMimeType(mimefilter.latin1());
01736     d.exp0rt(url);
01737 }
01738 
01739 
01740 
01741 Q_INT32 KisView::importImage(const KURL& urlArg)
01742 {
01743     KisImageSP currentImage = currentImg();
01744 
01745     if (!currentImage) {
01746         return 0;
01747     }
01748 
01749     KURL::List urls;
01750     Q_INT32 rc = 0;
01751 
01752     if (urlArg.isEmpty()) {
01753         QString mimelist = KoFilterManager::mimeFilter("application/x-krita", KoFilterManager::Import).join(" ");
01754         urls = KFileDialog::getOpenURLs(QString::null, mimelist, 0, i18n("Import Image"));
01755     } else {
01756         urls.push_back(urlArg);
01757     }
01758 
01759     if (urls.empty())
01760         return 0;
01761 
01762     for (KURL::List::iterator it = urls.begin(); it != urls.end(); ++it) {
01763         new KisImportCatcher( *it, currentImage );
01764     }
01765 
01766     updateCanvas();
01767 
01768     return rc;
01769 }
01770 
01771 void KisView::rotateLayer180()
01772 {
01773     rotateLayer( M_PI );
01774 }
01775 
01776 void KisView::rotateLayerLeft90()
01777 {
01778     rotateLayer( M_PI/2 - 2*M_PI );
01779 }
01780 
01781 void KisView::rotateLayerRight90()
01782 {
01783     rotateLayer( M_PI/2 );
01784 }
01785 
01786 void KisView::mirrorLayerX()
01787 {
01788     if (!currentImg()) return;
01789     KisPaintDeviceSP dev = currentImg()->activeDevice();
01790     if (!dev) return;
01791 
01792     KisTransaction * t = 0;
01793     if (undoAdapter() && undoAdapter()->undo()) {
01794         t = new KisTransaction(i18n("Mirror Layer X"), dev);
01795         Q_CHECK_PTR(t);
01796     }
01797 
01798     dev->mirrorX();
01799 
01800     if (t) undoAdapter()->addCommand(t);
01801 
01802     m_doc->setModified(true);
01803     layersUpdated();
01804     updateCanvas();
01805 }
01806 
01807 void KisView::mirrorLayerY()
01808 {
01809     if (!currentImg()) return;
01810     KisPaintDeviceSP dev = currentImg()->activeDevice();
01811     if (!dev) return;
01812 
01813     KisTransaction * t = 0;
01814     if (undoAdapter() && undoAdapter()->undo()) {
01815         t = new KisTransaction(i18n("Mirror Layer Y"), dev);
01816         Q_CHECK_PTR(t);
01817     }
01818 
01819     dev->mirrorY();
01820 
01821     if (t) undoAdapter()->addCommand(t);
01822 
01823     m_doc->setModified(true);
01824     layersUpdated();
01825     updateCanvas();
01826 }
01827 
01828 void KisView::scaleLayer(double sx, double sy, KisFilterStrategy *filterStrategy)
01829 {
01830     if (!currentImg()) return;
01831 
01832     KisPaintDeviceSP dev = currentImg()->activeDevice();
01833     if (!dev) return;
01834 
01835     KisSelectedTransaction * t = 0;
01836     if (undoAdapter() && undoAdapter()->undo()) {
01837         t = new KisSelectedTransaction(i18n("Scale Layer"), dev);
01838         Q_CHECK_PTR(t);
01839     }
01840 
01841     KisTransformWorker worker(dev, sx, sy, 0, 0, 0.0, 0, 0, m_progress, filterStrategy);
01842     worker.run();
01843 
01844     if (t) undoAdapter()->addCommand(t);
01845     currentImg()->rootLayer()->setDirty(false);
01846     m_doc->setModified(true);
01847     layersUpdated();
01848     updateCanvas();
01849 }
01850 
01851 void KisView::rotateLayer(double radians)
01852 {
01853     if (!currentImg()) return;
01854 
01855     KisPaintDeviceSP dev = currentImg()->activeDevice();
01856     if (!dev) return;
01857 
01858     KisSelectedTransaction * t = 0;
01859     if (undoAdapter() && undoAdapter()->undo()) {
01860         t = new KisSelectedTransaction(i18n("Rotate Layer"), dev);
01861         Q_CHECK_PTR(t);
01862     }
01863 
01864     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->get(KisID("Triangle"));
01865     QRect r;
01866     if(dev->hasSelection())
01867         r = dev->selection()->selectedExactRect();
01868     else
01869         r = dev->exactBounds();
01870     double cx = r.x()+r.width()/2.0;
01871     double cy = r.y()+r.height()/2.0;
01872     Q_INT32 tx = Q_INT32(cx*cos(radians) - cy*sin(radians) - cx + 0.5);
01873     Q_INT32 ty = Q_INT32(cy*cos(radians) + cx*sin(radians) - cy + 0.5);
01874 
01875     KisTransformWorker tw(dev, 1.0, 1.0, 0, 0, radians, -tx, -ty, m_progress, filter);
01876     tw.run();
01877 
01878     if (t) undoAdapter()->addCommand(t);
01879 
01880     m_doc->setModified(true);
01881     layersUpdated();
01882     updateCanvas();
01883 }
01884 
01885 void KisView::shearLayer(double angleX, double angleY)
01886 {
01887     if (!currentImg()) return;
01888 
01889     KisLayerSP layer = currentImg()->activeLayer();
01890     if (!layer) return;
01891 
01892     KisUndoAdapter * undo = 0;
01893     if ((undo = currentImg()->undoAdapter())) {
01894         undo->beginMacro(i18n("Shear layer"));
01895     }
01896 
01897     KisShearVisitor v(angleX, angleY, m_progress);
01898     v.setUndoAdapter(undo);
01899     layer->accept(v);
01900 
01901     if (undo) undo->endMacro();
01902 
01903     m_doc->setModified(true);
01904     layersUpdated();
01905     updateCanvas();
01906 }
01907 
01908 void KisView::flattenImage()
01909 {
01910     KisImageSP img = currentImg();
01911 
01912     if (img) {
01913         bool doIt = true;
01914 
01915         if (img->nHiddenLayers() > 0) {
01916             int answer = KMessageBox::warningYesNo(this,
01917                                    i18n("The image contains hidden layers that will be lost."),
01918                                    i18n("Flatten Image"),
01919                                    i18n("&Flatten Image"),
01920                                    KStdGuiItem::cancel());
01921 
01922             if (answer != KMessageBox::Yes) {
01923                 doIt = false;
01924             }
01925         }
01926 
01927         if (doIt) {
01928             img->flatten();
01929         }
01930     }
01931 }
01932 
01933 void KisView::mergeLayer()
01934 {
01935     KisImageSP img = currentImg();
01936     if (!img) return;
01937 
01938     KisLayerSP layer = img->activeLayer();
01939     if (!layer) return;
01940 
01941     img->mergeLayer(layer);
01942 }
01943 
01944 void KisView::preferences()
01945 {
01946 #ifdef HAVE_GL
01947     bool canvasWasOpenGL = m_canvas->isOpenGLCanvas();
01948 #endif
01949 
01950     if (PreferencesDialog::editPreferences())
01951     {
01952         KisConfig cfg;
01953         m_paletteManager->slotResetFont();
01954         resetMonitorProfile();
01955 
01956 #ifdef HAVE_GL
01957         if (cfg.useOpenGL() != canvasWasOpenGL) {
01958 
01959             disconnectCurrentImg();
01960 
01961             //XXX: Need to notify other views that this global setting has changed.
01962             if (cfg.useOpenGL()) {
01963                 m_OpenGLImageContext = KisOpenGLImageContext::getImageContext(m_image, monitorProfile());
01964                 m_canvas->createOpenGLCanvas(m_OpenGLImageContext->sharedContextWidget());
01965             } else
01966             {
01967                 m_OpenGLImageContext = 0;
01968                 m_canvas->createQPaintDeviceCanvas();
01969             }
01970 
01971             connectCurrentImg();
01972 
01973             resizeEvent(0);
01974         }
01975 
01976         if (cfg.useOpenGL()) {
01977             m_OpenGLImageContext->setMonitorProfile(monitorProfile());
01978         }
01979 #endif
01980 
01981         refreshKisCanvas();
01982 
01983         if (m_toolManager->currentTool()) {
01984             setCanvasCursor(m_toolManager->currentTool()->cursor());
01985         }
01986 
01987 #if defined(EXTENDED_X11_TABLET_SUPPORT)
01988         m_canvas->selectTabletDeviceEvents();
01989 #endif
01990 
01991     }
01992 }
01993 
01994 void KisView::layerCompositeOp(const KisCompositeOp& compositeOp)
01995 {
01996     KisImageSP img = currentImg();
01997     if (!img) return;
01998 
01999     KisLayerSP layer = img->activeLayer();
02000     if (!layer) return;
02001 
02002     if (img->undo()) {
02003         KNamedCommand *cmd = layer->setCompositeOpCommand(compositeOp);
02004         cmd->execute();
02005         undoAdapter()->addCommand(cmd);
02006     }
02007 }
02008 
02009 // range: 0 - 100
02010 void KisView::layerOpacity(int opacity, bool dontundo)
02011 {
02012     KisImageSP img = currentImg();
02013     if (!img) return;
02014 
02015     KisLayerSP layer = img->activeLayer();
02016     if (!layer) return;
02017 
02018     opacity = int(float(opacity * 255) / 100 + 0.5);
02019     if (opacity > 255)
02020         opacity = 255;
02021 
02022     if (opacity == layer->opacity()) return;
02023 
02024     if (dontundo)
02025         layer->setOpacity( opacity );
02026     else
02027     {
02028         if (img->undo()) {
02029             KNamedCommand *cmd = layer->setOpacityCommand(opacity);
02030             cmd->execute();
02031             undoAdapter()->addCommand(cmd);
02032         }
02033     }
02034 }
02035 
02036 void KisView::layerOpacityFinishedChanging( int previous, int opacity )
02037 {
02038     KisImageSP img = currentImg();
02039     if (!img) return;
02040 
02041     KisLayerSP layer = img->activeLayer();
02042     if (!layer) return;
02043 
02044     opacity = int(float(opacity * 255) / 100 + 0.5);
02045     if (opacity > 255)
02046         opacity = 255;
02047 
02048     previous = int(float(previous * 255) / 100 + 0.5);
02049     if (previous > 255)
02050         previous = 255;
02051 
02052     if (previous == opacity) return;
02053 
02054     if (img->undo()) {
02055         KNamedCommand *cmd = layer->setOpacityCommand(previous, opacity);
02056         m_adapter->addCommand(cmd);
02057     }
02058 }
02059 
02060 
02061 void KisView::showRuler()
02062 {
02063     if( m_RulerAction->isChecked() )
02064     {
02065         m_hRuler->show();
02066         m_vRuler->show();
02067     }
02068     else
02069     {
02070         m_hRuler->hide();
02071         m_vRuler->hide();
02072     }
02073 
02074     resizeEvent(0);
02075     refreshKisCanvas();
02076 }
02077 
02078 void KisView::slotUpdateFullScreen(bool toggle)
02079 {
02080     if (KoView::shell()) {
02081 
02082         uint newState = KoView::shell()->windowState();
02083 
02084         if (toggle) {
02085             newState |= Qt::WindowFullScreen;
02086         } else {
02087             newState &= ~Qt::WindowFullScreen;
02088         }
02089 
02090         KoView::shell()->setWindowState(newState);
02091     }
02092 }
02093 
02094 Q_INT32 KisView::docWidth() const
02095 {
02096     return currentImg() ? currentImg()->width() : 0;
02097 }
02098 
02099 Q_INT32 KisView::docHeight() const
02100 {
02101     return currentImg() ? currentImg()->height() : 0;
02102 }
02103 
02104 void KisView::scrollTo(Q_INT32 x, Q_INT32 y)
02105 {
02106     if (m_hScroll->isVisible()) {
02107         m_hScroll->setValue(x);
02108     }
02109     if (m_vScroll->isVisible()) {
02110         m_vScroll->setValue(y);
02111     }
02112 }
02113 
02114 void KisView::brushActivated(KisResource *brush)
02115 {
02116 
02117     m_brush = dynamic_cast<KisBrush*>(brush);
02118 
02119     if (m_brush )
02120     {
02121         emit brushChanged(m_brush);
02122         notifyObservers();
02123     }
02124 }
02125 
02126 void KisView::patternActivated(KisResource *pattern)
02127 {
02128     m_pattern = dynamic_cast<KisPattern*>(pattern);
02129 
02130     if (m_pattern) {
02131         emit patternChanged(m_pattern);
02132         notifyObservers();
02133     }
02134 }
02135 
02136 void KisView::gradientActivated(KisResource *gradient)
02137 {
02138 
02139     m_gradient = dynamic_cast<KisGradient*>(gradient);
02140 
02141     if (m_gradient) {
02142         emit gradientChanged(m_gradient);
02143         notifyObservers();
02144     }
02145 }
02146 
02147 void KisView::paintopActivated(const KisID & paintop, const KisPaintOpSettings *paintopSettings)
02148 {
02149     if (paintop.id().isNull() || paintop.id().isEmpty()) {
02150         return;
02151     }
02152 
02153     m_paintop = paintop;
02154     m_paintopSettings = paintopSettings;
02155     emit paintopChanged(m_paintop, paintopSettings);
02156     notifyObservers();
02157 }
02158 
02159 void KisView::setBGColor(const KisColor& c)
02160 {
02161     m_bg = c;
02162     notifyObservers();
02163     emit sigBGQColorChanged( c.toQColor() );
02164 }
02165 
02166 void KisView::setFGColor(const KisColor& c)
02167 {
02168     m_fg = c;
02169     notifyObservers();
02170     emit sigFGQColorChanged( c.toQColor() );
02171 }
02172 
02173 void KisView::slotSetFGColor(const KisColor& c)
02174 {
02175 
02176     m_fg = c;
02177     notifyObservers();
02178 }
02179 
02180 void KisView::slotSetBGColor(const KisColor& c)
02181 {
02182 
02183     m_bg = c;
02184     notifyObservers();
02185 }
02186 
02187 void KisView::slotSetFGQColor(const QColor& c)
02188 {
02189     KisColorSpace * monitorSpace = KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA"), m_monitorProfile);
02190     setFGColor(KisColor(c, monitorSpace));
02191     emit sigFGQColorChanged(c);
02192 }
02193 
02194 void KisView::slotSetBGQColor(const QColor& c)
02195 {
02196     KisColorSpace * monitorSpace = KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA"), m_monitorProfile);
02197     setBGColor(KisColor(c, monitorSpace));
02198     emit sigBGQColorChanged(c);
02199 }
02200 
02201 
02202 void KisView::setupPrinter(KPrinter& printer)
02203 {
02204     KisImageSP img = currentImg();
02205 
02206     if (img) {
02207         printer.setPageSelection(KPrinter::ApplicationSide);
02208         printer.setPageSize(KPrinter::A4);
02209         printer.setOrientation(KPrinter::Portrait);
02210     }
02211 }
02212 
02213 void KisView::print(KPrinter& printer)
02214 {
02215     QPainter gc(&printer);
02216 
02217     KisImageSP img = currentImg();
02218     if (!img) return;
02219 
02220     printer.setFullPage(true);
02221     gc.setClipping(false);
02222 
02223     KisConfig cfg;
02224     QString printerProfileName = cfg.printerProfile();
02225     KisProfile *  printerProfile = KisMetaRegistry::instance()->csRegistry() ->getProfileByName(printerProfileName);
02226 
02227     QRect r = img->bounds();
02228     img->renderToPainter(r.x(), r.y(), r.width(), r.height(), gc, printerProfile, KisImage::PAINT_IMAGE_ONLY, HDRExposure());
02229 }
02230 
02231 void KisView::paintToolOverlay(const QRegion& region)
02232 {
02233     if (!region.isEmpty() && m_toolManager->currentTool() && !m_toolIsPainting) {
02234         KisCanvasPainter gc(m_canvas);
02235 
02236         gc.setClipRegion(region);
02237         gc.setClipping(true);
02238 
02239         // Prevent endless loop if the tool needs to have the canvas repainted
02240         m_toolIsPainting = true;
02241         m_toolManager->currentTool()->paint(gc, region.boundingRect());
02242         m_toolIsPainting = false;
02243     }
02244 }
02245 
02246 void KisView::canvasGotPaintEvent(QPaintEvent *event)
02247 {
02248     if (m_canvas->isOpenGLCanvas()) {
02249         paintOpenGLView(event->rect());
02250     } else {
02251         paintQPaintDeviceView(event->region());
02252     }
02253 }
02254 
02255 void KisView::canvasGotButtonPressEvent(KisButtonPressEvent *e)
02256 {
02257 #if defined(EXTENDED_X11_TABLET_SUPPORT)
02258     // The event filter doesn't see tablet events going to the canvas.
02259     if (e->device() != KisInputDevice::mouse()) {
02260         m_tabletEventTimer.start();
02261     }
02262 #endif // EXTENDED_X11_TABLET_SUPPORT
02263 
02264     if (e->device() != currentInputDevice()) {
02265         if (e->device() == KisInputDevice::mouse()) {
02266             if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) {
02267                 setInputDevice(KisInputDevice::mouse());
02268             }
02269         } else {
02270             setInputDevice(e->device());
02271         }
02272     }
02273 
02274     KisImageSP img = currentImg();
02275 
02276 //    if (img) {
02277 //        QPoint pt = mapToScreen(e->pos().floorQPoint());
02278 //        KisGuideMgr *mgr = img->guides();
02279 //
02280 //        m_lastGuidePoint = mapToScreen(e->pos().floorQPoint());
02281 //        m_currentGuide = 0;
02282 //
02283 //        if ((e->state() & ~Qt::ShiftButton) == Qt::NoButton) {
02284 //            KisGuideSP gd = mgr->find(static_cast<Q_INT32>(pt.x() / zoom()), static_cast<Q_INT32>(pt.y() / zoom()), QMAX(2.0, 2.0 / zoom()));
02285 //
02286 //            if (gd) {
02287 //                m_currentGuide = gd;
02288 //
02289 //                if ((e->button() == Qt::RightButton) || ((e->button() & Qt::ShiftButton) == Qt::ShiftButton)) {
02290 //                    if (gd->isSelected())
02291 //                        mgr->unselect(gd);
02292 //                    else
02293 //                        mgr->select(gd);
02294 //              } else {
02295 //                    if (!gd->isSelected()) {
02296 //                        mgr->unselectAll();
02297 //                        mgr->select(gd);
02298 //                    }
02299 //                }
02300 //
02301 //                updateGuides();
02302 //                return;
02303 //            }
02304 //        }
02305 //    }
02306     if (e->button() == Qt::RightButton) {
02307         QPopupMenu * m_popup = 0;
02308         if (factory()) {
02309             Q_ASSERT(factory());
02310             m_popup = (QPopupMenu *)factory()->container("image_popup", this);
02311         }
02312         if (m_popup) {
02313             m_popup->popup(e->globalPos().roundQPoint());
02314         }
02315     }
02316     else if (e->device() == currentInputDevice() && m_toolManager->currentTool()) {
02317         KisPoint p = viewToWindow(e->pos());
02318         // somewhat of a hack: we should actually test if we intersect with the scrollers,
02319         // but the globalPos seems to be off by a few pixels
02320         if (m_vScroll->draggingSlider() || m_hScroll->draggingSlider())
02321             return;
02322 
02323         if (m_toolManager->currentTool()->wantsAutoScroll()) {
02324             enableAutoScroll();
02325         }
02326 
02327         KisButtonPressEvent ev(e->device(), p, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->button(), e->state());
02328         m_toolManager->currentTool()->buttonPress(&ev);
02329     }
02330 }
02331 
02332 void KisView::canvasGotMoveEvent(KisMoveEvent *e)
02333 {
02334 #if defined(EXTENDED_X11_TABLET_SUPPORT)
02335     // The event filter doesn't see tablet events going to the canvas.
02336     if (e->device() != KisInputDevice::mouse()) {
02337         m_tabletEventTimer.start();
02338     }
02339 #endif // EXTENDED_X11_TABLET_SUPPORT
02340 
02341     if (e->device() != currentInputDevice()) {
02342         if (e->device() == KisInputDevice::mouse()) {
02343             if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) {
02344                 setInputDevice(KisInputDevice::mouse());
02345             }
02346         } else {
02347             setInputDevice(e->device());
02348         }
02349     }
02350 
02351     KisImageSP img = currentImg();
02352 
02353     m_hRuler->updatePointer(e->pos().floorX() - m_canvasXOffset, e->pos().floorY() - m_canvasYOffset);
02354     m_vRuler->updatePointer(e->pos().floorX() - m_canvasXOffset, e->pos().floorY() - m_canvasYOffset);
02355 
02356     KisPoint wp = viewToWindow(e->pos());
02357 
02358 #if 0
02359     if (img && m_currentGuide) {
02360         QPoint p = mapToScreen(e->pos().floorQPoint());
02361         KisGuideMgr *mgr = img->guides();
02362 
02363         if (((e->state() & Qt::LeftButton) == Qt::LeftButton) && mgr->hasSelected()) {
02364             eraseGuides();
02365             p -= m_lastGuidePoint;
02366 
02367             if (p.x())
02368                 mgr->moveSelectedByX(p.x() / zoom());
02369 
02370             if (p.y())
02371                 mgr->moveSelectedByY(p.y() / zoom());
02372 
02373             m_doc->setModified(true);
02374             paintGuides();
02375         }
02376     } else
02377 #endif
02378     if (e->device() == currentInputDevice() && m_toolManager->currentTool()) {
02379         KisMoveEvent ev(e->device(), wp, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->state());
02380 
02381         m_toolManager->currentTool()->move(&ev);
02382     }
02383 
02384 //    m_lastGuidePoint = mapToScreen(e->pos().floorQPoint());
02385     emit cursorPosition(wp.floorX(), wp.floorY());
02386 }
02387 
02388 int KisView::leftBorder() const
02389 {
02390   return m_rulerThickness;
02391 }
02392 
02393 int KisView::rightBorder() const
02394 {
02395   return m_hScrollBarExtent;
02396 }
02397 
02398 int KisView::topBorder() const
02399 {
02400   return m_rulerThickness;
02401 }
02402 
02403 int KisView::bottomBorder() const
02404 {
02405   return m_vScrollBarExtent;
02406 }
02407 
02408 void KisView::mouseMoveEvent(QMouseEvent *e)
02409 {
02410     KisMoveEvent ke(currentInputDevice(), e->pos(), e->globalPos(), PRESSURE_DEFAULT, 0, 0, e->state());
02411     canvasGotMoveEvent(&ke);
02412 }
02413 
02414 void KisView::slotAutoScroll(const QPoint &p)
02415 {
02416     scrollTo(horzValue()+p.x(), vertValue()+p.y());
02417 }
02418 
02419 void KisView::canvasGotButtonReleaseEvent(KisButtonReleaseEvent *e)
02420 {
02421 #if defined(EXTENDED_X11_TABLET_SUPPORT)
02422     // The event filter doesn't see tablet events going to the canvas.
02423     if (e->device() != KisInputDevice::mouse()) {
02424         m_tabletEventTimer.start();
02425     }
02426 #endif // EXTENDED_X11_TABLET_SUPPORT
02427 
02428     if (e->device() != currentInputDevice()) {
02429         if (e->device() == KisInputDevice::mouse()) {
02430             if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) {
02431                 setInputDevice(KisInputDevice::mouse());
02432             }
02433         } else {
02434             setInputDevice(e->device());
02435         }
02436     }
02437 
02438     KisImageSP img = currentImg();
02439 
02440 //    if (img && m_currentGuide) {
02441 //        m_currentGuide = 0;
02442 //    } else
02443     if (e->device() == currentInputDevice() && m_toolManager->currentTool()) {
02444         KisPoint p = viewToWindow(e->pos());
02445         KisButtonReleaseEvent ev(e->device(), p, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->button(), e->state());
02446 
02447         disableAutoScroll();
02448         if (m_toolManager->currentTool()) {
02449             m_toolManager->currentTool()->buttonRelease(&ev);
02450         }
02451     }
02452 }
02453 
02454 void KisView::canvasGotDoubleClickEvent(KisDoubleClickEvent *e)
02455 {
02456 #if defined(EXTENDED_X11_TABLET_SUPPORT)
02457     // The event filter doesn't see tablet events going to the canvas.
02458     if (e->device() != KisInputDevice::mouse()) {
02459         m_tabletEventTimer.start();
02460     }
02461 #endif // EXTENDED_X11_TABLET_SUPPORT
02462 
02463     if (e->device() != currentInputDevice()) {
02464         if (e->device() == KisInputDevice::mouse()) {
02465             if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) {
02466                 setInputDevice(KisInputDevice::mouse());
02467             }
02468         } else {
02469             setInputDevice(e->device());
02470         }
02471     }
02472 
02473     if (e->device() == currentInputDevice() && m_toolManager->currentTool()) {
02474         KisPoint p = viewToWindow(e->pos());
02475         KisDoubleClickEvent ev(e->device(), p, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->button(), e->state());
02476 
02477         if (m_toolManager->currentTool()) {
02478             m_toolManager->currentTool()->doubleClick(&ev);
02479         }
02480     }
02481 }
02482 
02483 void KisView::canvasGotEnterEvent(QEvent *e)
02484 {
02485     Q_UNUSED( e );
02486 }
02487 
02488 void KisView::canvasGotLeaveEvent (QEvent *e)
02489 {
02490     Q_UNUSED( e );
02491 }
02492 
02493 void KisView::canvasGotMouseWheelEvent(QWheelEvent *event)
02494 {
02495     //if(event->state() == ControlButton )
02496     //{
02497         if(event->delta() / 120 != 0)
02498         {
02499             if(event->delta() > 0)
02500             {
02501                 zoomIn();
02502             } else {
02503                 zoomOut();
02504             }
02505         if (m_oldTool) {
02506                 KisCanvasPainter gc(m_canvas);
02507                 m_oldTool->paint(gc);
02508             }
02509         }
02510     //} else {
02511     //    QApplication::sendEvent(m_vScroll, event);
02512     //}
02513 }
02514 
02515 void KisView::canvasGotKeyPressEvent(QKeyEvent *event)
02516 {
02517     if (!m_toolManager->currentTool()) {
02518         event->ignore();
02519         return;
02520     }
02521 
02522     if (event->key() == Qt::Key_Space) {
02523         if (!m_panning) {
02524             // Set tool temporarily to pan
02525             m_panning = true;
02526             m_oldTool = m_toolManager->currentTool();
02527             m_toolManager->setCurrentTool( "tool_pan" );
02528         }
02529         else {
02530             // Unset panning
02531             m_panning = false;
02532             m_toolManager->setCurrentTool( m_oldTool );
02533             m_oldTool = 0;
02534         }
02535     }
02536     if (m_toolManager->currentTool())
02537         m_toolManager->currentTool()->keyPress(event);
02538 }
02539 
02540 void KisView::canvasGotKeyReleaseEvent(QKeyEvent *event)
02541 {
02542     if (m_toolManager->currentTool())
02543         m_toolManager->currentTool()->keyRelease(event);
02544 }
02545 
02546 void KisView::canvasGotDragEnterEvent(QDragEnterEvent *event)
02547 {
02548     bool accept = false;
02549 
02550     // Only accept drag if we're not busy, particularly as we may
02551     // be showing a progress bar and calling qApp->processEvents().
02552     if (KURLDrag::canDecode(event) && QApplication::overrideCursor() == 0) {
02553         accept = true;
02554     }
02555 
02556     event->accept(accept);
02557 }
02558 
02559 void KisView::canvasGotDropEvent(QDropEvent *event)
02560 {
02561     KURL::List urls;
02562 
02563     if (KURLDrag::decode(event, urls))
02564     {
02565         if (urls.count() > 0) {
02566             enum enumActionId {
02567                 addLayerId = 1,
02568                 addDocumentId = 2,
02569                 cancelId
02570             };
02571 
02572             KPopupMenu popup(this, "drop_popup");
02573 
02574             if (urls.count() == 1) {
02575                 if (currentImg() != 0) {
02576                     popup.insertItem(i18n("Insert as New Layer"), addLayerId);
02577                 }
02578                 popup.insertItem(i18n("Open in New Document"), addDocumentId);
02579             }
02580             else {
02581                 if (currentImg() != 0) {
02582                     popup.insertItem(i18n("Insert as New Layers"), addLayerId);
02583                 }
02584                 popup.insertItem(i18n("Open in New Documents"), addDocumentId);
02585             }
02586 
02587             popup.insertSeparator();
02588             popup.insertItem(i18n("Cancel"), cancelId);
02589 
02590             int actionId = popup.exec(QCursor::pos());
02591 
02592             if (actionId >= 0 && actionId != cancelId) {
02593                 for (KURL::List::ConstIterator it = urls.begin (); it != urls.end (); ++it) {
02594                     KURL url = *it;
02595 
02596                     switch (actionId) {
02597                     case addLayerId:
02598                         importImage(url);
02599                         break;
02600                     case addDocumentId:
02601                         if (shell() != 0) {
02602                             shell()->openDocument(url);
02603                         }
02604                         break;
02605                     }
02606                 }
02607             }
02608         }
02609     }
02610 }
02611 
02612 void KisView::layerProperties()
02613 {
02614     if (currentImg() && currentImg()->activeLayer())
02615         showLayerProperties(currentImg()->activeLayer());
02616 }
02617 
02618 namespace {
02619     class KisChangeFilterCmd : public KNamedCommand {
02620         typedef KNamedCommand super;
02621 
02622         public:
02623             // The QStrings are the _serialized_ configs
02624             KisChangeFilterCmd(KisAdjustmentLayerSP layer,
02625                                KisFilterConfiguration* config,
02626                                const QString& before,
02627                                const QString& after) : super(i18n("Change Filter"))
02628             {
02629                 m_layer = layer;
02630                 m_config = config;
02631                 m_before = before;
02632                 m_after = after;
02633             }
02634         public:
02635             virtual void execute()
02636             {
02637                 QApplication::setOverrideCursor(KisCursor::waitCursor());
02638                 m_config->fromXML(m_after);
02639                 //Q_ASSERT(m_after == m_config->toString());
02640                 m_layer->setFilter(m_config);
02641                 m_layer->setDirty();
02642                 QApplication::restoreOverrideCursor();
02643             }
02644 
02645             virtual void unexecute()
02646             {
02647                 QApplication::setOverrideCursor(KisCursor::waitCursor());
02648                 m_config->fromXML(m_before);
02649                 //Q_ASSERT(m_before == m_config->toString());
02650                 m_layer->setFilter(m_config);
02651                 m_layer->setDirty();
02652                 QApplication::restoreOverrideCursor();
02653             }
02654         private:
02655             KisAdjustmentLayerSP m_layer;
02656             KisFilterConfiguration* m_config;
02657             QString m_before;
02658             QString m_after;
02659     };
02660 }
02661 
02662 void KisView::showLayerProperties(KisLayerSP layer)
02663 {
02664     Q_ASSERT( layer );
02665     if ( !layer ) return;
02666 
02667     KisColorSpace * cs = 0;
02668     KisPaintLayer * pl = dynamic_cast<KisPaintLayer*>( layer.data() );
02669     if ( pl ) {
02670         cs = pl->paintDevice()->colorSpace();
02671     }
02672     else {
02673         cs = layer->image()->colorSpace();
02674     }
02675 
02676 
02677     if (KisAdjustmentLayerSP alayer = dynamic_cast<KisAdjustmentLayer*>(layer.data()))
02678     {
02679         KisDlgAdjLayerProps dlg(alayer, alayer->name(), i18n("Adjustment Layer Properties"), this, "dlgadjlayerprops");
02680         QString before = dlg.filterConfiguration()->toString();
02681         if (dlg.exec() == QDialog::Accepted)
02682         {
02683             KisChangeFilterCmd * cmd = new KisChangeFilterCmd(alayer,
02684                     dlg.filterConfiguration(),
02685                     before,
02686                     dlg.filterConfiguration()->toString());
02687             cmd->execute();
02688             m_adapter->addCommand(cmd);
02689             m_doc->setModified( true );
02690         }
02691     }
02692     else
02693     {
02694         KisDlgLayerProperties dlg(layer->name(),
02695                                   layer->opacity(),
02696                                   layer->compositeOp(),
02697                                   cs);
02698         if (dlg.exec() == QDialog::Accepted)
02699         {
02700             if (layer->name() != dlg.getName() ||
02701                 layer->opacity() != dlg.getOpacity() ||
02702                 layer->compositeOp() != dlg.getCompositeOp())
02703             {
02704                 QApplication::setOverrideCursor(KisCursor::waitCursor());
02705                 m_adapter->beginMacro(i18n("Property Changes"));
02706                 layer->image()->setLayerProperties(layer, dlg.getOpacity(), dlg.getCompositeOp(), dlg.getName());
02707                 layer->setDirty();
02708                 m_adapter->endMacro();
02709                 QApplication::restoreOverrideCursor();
02710                 m_doc->setModified( true );
02711             }
02712         }
02713     }
02714 }
02715 
02716 void KisView::layerAdd()
02717 {
02718     KisImageSP img = currentImg();
02719     if (img && img->activeLayer()) {
02720         addLayer(img->activeLayer()->parent(), img->activeLayer());
02721     }
02722     else if (img)
02723         addLayer(static_cast<KisGroupLayer*>(img->rootLayer().data()), 0);
02724 }
02725 
02726 void KisView::addLayer(KisGroupLayerSP parent, KisLayerSP above)
02727 {
02728     KisImageSP img = currentImg();
02729     if (img) {
02730         KisConfig cfg;
02731         QString profilename;
02732         if(img->colorSpace()->getProfile())
02733             profilename = img->colorSpace()->getProfile()->productName();
02734         NewLayerDialog dlg(img->colorSpace()->id(), profilename, img->nextLayerName(), this);
02735 
02736         if (dlg.exec() == QDialog::Accepted) {
02737             KisColorSpace* cs = KisMetaRegistry::instance()-> csRegistry() ->
02738                     getColorSpace(dlg.colorSpaceID(),dlg.profileName());
02739             KisLayerSP layer = new KisPaintLayer(img, dlg.layerName(), dlg.opacity(), cs);
02740             if (layer) {
02741                 layer->setCompositeOp(dlg.compositeOp());
02742                 img->addLayer(layer, parent.data(), above);
02743                 updateCanvas();
02744             } else {
02745                 KMessageBox::error(this, i18n("Could not add layer to image."), i18n("Layer Error"));
02746             }
02747         }
02748         else {
02749             img->rollBackLayerName();
02750         }
02751     }
02752 }
02753 
02754 void KisView::addGroupLayer(KisGroupLayerSP parent, KisLayerSP above)
02755 {
02756     KisImageSP img = currentImg();
02757     if (img) {
02758         QString profilename;
02759         if(img->colorSpace()->getProfile())
02760             profilename = img->colorSpace()->getProfile()->productName();
02761         KisConfig cfg;
02762         NewLayerDialog dlg(img->colorSpace()->id(), profilename, img->nextLayerName(), this);
02763         dlg.setColorSpaceEnabled(false);
02764 
02765         if (dlg.exec() == QDialog::Accepted) {
02766             KisLayerSP layer = new KisGroupLayer(img, dlg.layerName(), dlg.opacity());
02767             if (layer) {
02768                 layer->setCompositeOp(dlg.compositeOp());
02769                 img->addLayer(layer, parent.data(), above);
02770                 updateCanvas();
02771             } else {
02772                 KMessageBox::error(this, i18n("Could not add layer to image."), i18n("Layer Error"));
02773             }
02774         }
02775     }
02776 }
02777 
02778 void KisView::addPartLayer()
02779 {
02780     KisImageSP img = currentImg();
02781     if (!img) return;
02782 
02783     addPartLayer(img->rootLayer(), img->rootLayer()->firstChild(), m_actionPartLayer->documentEntry());
02784 }
02785 
02786 void KisView::addPartLayer(KisGroupLayerSP parent, KisLayerSP above, const KoDocumentEntry& entry)
02787 {
02788     delete m_partHandler; // Only one at a time
02789     m_partHandler = new KisPartLayerHandler(this, entry, parent, above);
02790 
02791     disconnect(m_canvas, SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)), this, 0);
02792     disconnect(m_canvas, SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)), this, 0);
02793     disconnect(m_canvas, SIGNAL(sigGotMoveEvent(KisMoveEvent*)), this, 0);
02794     disconnect(m_canvas, SIGNAL(sigGotKeyPressEvent(QKeyEvent*)), this, 0);
02795 
02796     connect(m_canvas, SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)),
02797             m_partHandler, SLOT(gotButtonPressEvent(KisButtonPressEvent*)));
02798     connect(m_canvas, SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)),
02799             m_partHandler, SLOT(gotButtonReleaseEvent(KisButtonReleaseEvent*)));
02800     connect(m_canvas, SIGNAL(sigGotMoveEvent(KisMoveEvent*)),
02801             m_partHandler, SLOT(gotMoveEvent(KisMoveEvent*)));
02802     connect(m_canvas, SIGNAL(sigGotKeyPressEvent(QKeyEvent*)),
02803             m_partHandler, SLOT(gotKeyPressEvent(QKeyEvent*)));
02804 
02805     connect(m_partHandler, SIGNAL(sigGotMoveEvent(KisMoveEvent*)),
02806             this, SLOT(canvasGotMoveEvent(KisMoveEvent*)));
02807     connect(m_partHandler, SIGNAL(sigGotKeyPressEvent(QKeyEvent*)),
02808             this, SLOT(canvasGotKeyPressEvent(QKeyEvent*)));
02809     connect(m_partHandler, SIGNAL(handlerDone()),
02810             this, SLOT(reconnectAfterPartInsert()));
02811 }
02812 
02813 void KisView::insertPart(const QRect& viewRect, const KoDocumentEntry& entry,
02814                          KisGroupLayerSP parent, KisLayerSP above) {
02815     KisImageSP img = currentImg();
02816     if (!img) return;
02817 
02818     KoDocument* doc = entry.createDoc(m_doc);
02819     if ( !doc )
02820         return;
02821 
02822     if ( !doc->showEmbedInitDialog(this) )
02823         return;
02824 
02825     QRect rect = viewToWindow(viewRect);
02826 
02827     KisChildDoc * childDoc = m_doc->createChildDoc(rect, doc);
02828 
02829     KisPartLayerImpl* partLayer = new KisPartLayerImpl(img, childDoc);
02830     partLayer->setDocType(entry.service()->genericName());
02831     img->addLayer(partLayer, parent, above);
02832     m_doc->setModified(true);
02833 
02834     reconnectAfterPartInsert();
02835 }
02836 
02837 void KisView::reconnectAfterPartInsert() {
02838     connect(m_canvas, SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)),
02839             this, SLOT(canvasGotButtonPressEvent(KisButtonPressEvent*)));
02840     connect(m_canvas, SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)),
02841             this, SLOT(canvasGotButtonReleaseEvent(KisButtonReleaseEvent*)));
02842     connect(m_canvas, SIGNAL(sigGotMoveEvent(KisMoveEvent*)),
02843             this, SLOT(canvasGotMoveEvent(KisMoveEvent*)));
02844     connect(m_canvas, SIGNAL(sigGotKeyPressEvent(QKeyEvent*)),
02845             this, SLOT(canvasGotKeyPressEvent(QKeyEvent*)));
02846 
02847     delete m_partHandler;
02848     m_partHandler = 0;
02849 }
02850 
02851 void KisView::addAdjustmentLayer()
02852 {
02853     KisImageSP img = currentImg();
02854     if (!img) return;
02855 
02856     addAdjustmentLayer( img->activeLayer()->parent(), img->activeLayer() );
02857 }
02858 
02859 void KisView::addAdjustmentLayer(KisGroupLayerSP parent, KisLayerSP above)
02860 {
02861     Q_ASSERT(parent);
02862     Q_ASSERT(above);
02863 
02864     KisImageSP img = currentImg();
02865     if (!img) return;
02866 
02867     KisLayerSP l = img->activeLayer();
02868 
02869     KisPaintDeviceSP dev;
02870 
02871     //  Argh! I hate having to cast, cast and cast again to see what kind of a layer I've got!
02872     KisPaintLayer * pl = dynamic_cast<KisPaintLayer*>(l.data());
02873     if (pl) {
02874         dev = pl->paintDevice();
02875     }
02876     else {
02877         KisGroupLayer * gl = dynamic_cast<KisGroupLayer*>(l.data());
02878         if (gl) {
02879             dev = gl->projection(img->bounds());
02880         }
02881         else {
02882             KisAdjustmentLayer * al = dynamic_cast<KisAdjustmentLayer*>(l.data());
02883             if (al) {
02884                 dev = al->cachedPaintDevice();
02885             }
02886             else {
02887                 return;
02888             }
02889         }
02890     }
02891 
02892     KisDlgAdjustmentLayer dlg(img, img->nextLayerName(), i18n("New Adjustment Layer"), this, "dlgadjustmentlayer");
02893     if (dlg.exec() == QDialog::Accepted) {
02894         KisSelectionSP selection = 0;
02895         if (dev->hasSelection()) {
02896             selection = dev->selection();
02897         }
02898         KisFilterConfiguration * filter = dlg.filterConfiguration();
02899         QString name = dlg.layerName();
02900 
02901         addAdjustmentLayer( parent, above, name, filter, selection);
02902 
02903     }
02904 }
02905 
02906 void KisView::addAdjustmentLayer(KisGroupLayerSP parent, KisLayerSP above, const QString & name,
02907                                  KisFilterConfiguration * filter, KisSelectionSP selection)
02908 {
02909     Q_ASSERT(parent);
02910     Q_ASSERT(above);
02911     Q_ASSERT(filter);
02912 
02913     KisImageSP img = currentImg();
02914     if (!img) return;
02915 
02916     KisAdjustmentLayer * l = new KisAdjustmentLayer(img, name, filter, selection);
02917     img->addLayer(l, parent, above);
02918 }
02919 
02920 void KisView::slotChildActivated(bool a) {
02921     // It should be so that the only part (child) we can activate, is the current layer:
02922     if (currentImg() && currentImg()->activeLayer())
02923     {
02924         if (a) {
02925             currentImg()->activeLayer()->activate();
02926         } else {
02927             currentImg()->activeLayer()->deactivate();
02928         }
02929     }
02930 
02931     super::slotChildActivated(a);
02932 }
02933 
02934 void KisView::layerRemove()
02935 {
02936     KisImageSP img = currentImg();
02937 
02938     if (img) {
02939         KisLayerSP layer = img->activeLayer();
02940 
02941         if (layer) {
02942 
02943 
02944             img->removeLayer(layer);
02945 
02946             if (layer->parent())
02947                 layer->parent()->setDirty(layer->extent());
02948 
02949             updateCanvas();
02950             layerUpdateGUI(img->activeLayer() != 0);
02951         }
02952     }
02953 }
02954 
02955 void KisView::layerDuplicate()
02956 {
02957     KisImageSP img = currentImg();
02958 
02959     if (!img)
02960         return;
02961 
02962     KisLayerSP active = img->activeLayer();
02963 
02964     if (!active)
02965         return;
02966 
02967     KisLayerSP dup = active->clone();
02968     dup->setName(i18n("Duplicate of '%1'").arg(active->name()));
02969     img->addLayer(dup, active->parent().data(), active);
02970     if (dup) {
02971         img->activate( dup );
02972         updateCanvas();
02973     } else {
02974         KMessageBox::error(this, i18n("Could not add layer to image."), i18n("Layer Error"));
02975     }
02976 }
02977 
02978 void KisView::layerRaise()
02979 {
02980     KisImageSP img = currentImg();
02981     KisLayerSP layer;
02982 
02983     if (!img)
02984         return;
02985 
02986     layer = img->activeLayer();
02987 
02988     img->raiseLayer(layer);
02989 }
02990 
02991 void KisView::layerLower()
02992 {
02993     KisImageSP img = currentImg();
02994     KisLayerSP layer;
02995 
02996     if (!img)
02997         return;
02998 
02999     layer = img->activeLayer();
03000 
03001     img->lowerLayer(layer);
03002 }
03003 
03004 void KisView::layerFront()
03005 {
03006     KisImageSP img = currentImg();
03007     KisLayerSP layer;
03008 
03009     if (!img)
03010         return;
03011 
03012     layer = img->activeLayer();
03013     img->toTop(layer);
03014 }
03015 
03016 void KisView::layerBack()
03017 {
03018     KisImageSP img = currentImg();
03019     if (!img) return;
03020 
03021     KisLayerSP layer;
03022 
03023     layer = img->activeLayer();
03024     img->toBottom(layer);
03025 }
03026 
03027 void KisView::layersUpdated()
03028 {
03029     KisImageSP img = currentImg();
03030     if (!img) return;
03031 
03032     KisLayerSP layer = img->activeLayer();
03033 
03034     layerUpdateGUI(img && layer);
03035 
03036     notifyObservers();
03037 }
03038 
03039 void KisView::layerToggleVisible()
03040 {
03041     KisImageSP img = currentImg();
03042     if (!img) return;
03043 
03044     KisLayerSP layer = img->activeLayer();
03045     if (!layer) return;
03046 
03047     layer->setVisible(!layer->visible());
03048 }
03049 
03050 void KisView::layerToggleLocked()
03051 {
03052     KisImageSP img = currentImg();
03053     if (!img) return;
03054 
03055     KisLayerSP layer = img->activeLayer();
03056     if (!layer) return;
03057 
03058     layer->setLocked(!layer->locked());
03059 }
03060 
03061 void KisView::actLayerVisChanged(int show)
03062 {
03063     m_actLayerVis = (show != 0);
03064 }
03065 
03066 bool KisView::activeLayerHasSelection()
03067 {
03068     return m_image && m_image->activeDevice() && m_image->activeDevice()->hasSelection();
03069 }
03070 
03071 void KisView::scrollH(int value)
03072 {
03073     m_hRuler->updateVisibleArea(value, 0);
03074 
03075     int xShift = m_scrollX - value;
03076     m_scrollX = value;
03077 
03078     if (m_canvas->isUpdatesEnabled()) {
03079         if (xShift > 0) {
03080 
03081             if (m_canvas->isOpenGLCanvas()) {
03082                 paintOpenGLView(QRect(0, 0, m_canvas->width(), m_canvas->height()));
03083             } else {
03084                 QRect drawRect(0, 0, xShift, m_canvasPixmap.height());
03085 
03086                 bitBlt(&m_canvasPixmap, xShift, 0, &m_canvasPixmap, 0, 0, m_canvasPixmap.width() - xShift, m_canvasPixmap.height());
03087 
03088                 updateQPaintDeviceCanvas(viewToWindow(drawRect));
03089                 m_canvas->repaint();
03090             }
03091         } else if (xShift < 0) {
03092 
03093             QRect drawRect(m_canvasPixmap.width() + xShift, 0, -xShift, m_canvasPixmap.height());
03094 
03095             if (m_canvas->isOpenGLCanvas()) {
03096                 paintOpenGLView(QRect(0, 0, m_canvas->width(), m_canvas->height()));
03097             } else {
03098                 bitBlt(&m_canvasPixmap, 0, 0, &m_canvasPixmap, -xShift, 0, m_canvasPixmap.width() + xShift, m_canvasPixmap.height());
03099 
03100                 updateQPaintDeviceCanvas(viewToWindow(drawRect));
03101                 m_canvas->repaint();
03102             }
03103         }
03104     if (m_oldTool) {
03105             KisCanvasPainter gc(m_canvas);
03106             m_oldTool->paint(gc);
03107         }
03108     }
03109 
03110     if (xShift != 0) {
03111         // XXX do sth with the childframe or so
03112     }
03113     emit viewTransformationsChanged();
03114 }
03115 
03116 void KisView::scrollV(int value)
03117 {
03118     m_vRuler->updateVisibleArea(0, value);
03119 
03120     int yShift = m_scrollY - value;
03121     m_scrollY = value;
03122 
03123     if (m_canvas->isUpdatesEnabled()) {
03124         if (yShift > 0) {
03125 
03126             if (m_canvas->isOpenGLCanvas()) {
03127                 paintOpenGLView(QRect(0, 0, m_canvas->width(), m_canvas->height()));
03128             } else {
03129                 QRect drawRect(0, 0, m_canvasPixmap.width(), yShift);
03130 
03131                 bitBlt(&m_canvasPixmap, 0, yShift, &m_canvasPixmap, 0, 0, m_canvasPixmap.width(), m_canvasPixmap.height() - yShift);
03132 
03133                 updateQPaintDeviceCanvas(viewToWindow(drawRect));
03134                 m_canvas->repaint();
03135             }
03136         } else if (yShift < 0) {
03137 
03138             if (m_canvas->isOpenGLCanvas()) {
03139                 paintOpenGLView(QRect(0, 0, m_canvas->width(), m_canvas->height()));
03140             } else {
03141                 QRect drawRect(0, m_canvasPixmap.height() + yShift, m_canvasPixmap.width(), -yShift);
03142 
03143                 bitBlt(&m_canvasPixmap, 0, 0, &m_canvasPixmap, 0, -yShift, m_canvasPixmap.width(), m_canvasPixmap.height() + yShift);
03144 
03145                 updateQPaintDeviceCanvas(viewToWindow(drawRect));
03146                 m_canvas->repaint();
03147             }
03148         }
03149     if (m_oldTool) {
03150             KisCanvasPainter gc(m_canvas);
03151             m_oldTool->paint(gc);
03152         }
03153     }
03154 
03155     if (yShift != 0) {
03156         // XXX do sth with the childframe or so
03157     }
03158     emit viewTransformationsChanged();
03159 }
03160 
03161 void KisView::setupCanvas()
03162 {
03163     m_canvas = new KisCanvas(this, "kis_canvas");
03164     m_canvas->setFocusPolicy( QWidget::StrongFocus );
03165     QObject::connect(m_canvas, SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)), this, SLOT(canvasGotButtonPressEvent(KisButtonPressEvent*)));
03166     QObject::connect(m_canvas, SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)), this, SLOT(canvasGotButtonReleaseEvent(KisButtonReleaseEvent*)));
03167     QObject::connect(m_canvas, SIGNAL(sigGotDoubleClickEvent(KisDoubleClickEvent*)), this, SLOT(canvasGotDoubleClickEvent(KisDoubleClickEvent*)));
03168     QObject::connect(m_canvas, SIGNAL(sigGotMoveEvent(KisMoveEvent*)), this, SLOT(canvasGotMoveEvent(KisMoveEvent*)));
03169     QObject::connect(m_canvas, SIGNAL(sigGotPaintEvent(QPaintEvent*)), this, SLOT(canvasGotPaintEvent(QPaintEvent*)));
03170     QObject::connect(m_canvas, SIGNAL(sigGotEnterEvent(QEvent*)), this, SLOT(canvasGotEnterEvent(QEvent*)));
03171     QObject::connect(m_canvas, SIGNAL(sigGotLeaveEvent(QEvent*)), this, SLOT(canvasGotLeaveEvent(QEvent*)));
03172     QObject::connect(m_canvas, SIGNAL(sigGotMouseWheelEvent(QWheelEvent*)), this, SLOT(canvasGotMouseWheelEvent(QWheelEvent*)));
03173     QObject::connect(m_canvas, SIGNAL(sigGotKeyPressEvent(QKeyEvent*)), this, SLOT(canvasGotKeyPressEvent(QKeyEvent*)));
03174     QObject::connect(m_canvas, SIGNAL(sigGotKeyReleaseEvent(QKeyEvent*)), this, SLOT(canvasGotKeyReleaseEvent(QKeyEvent*)));
03175     QObject::connect(m_canvas, SIGNAL(sigGotDragEnterEvent(QDragEnterEvent*)), this, SLOT(canvasGotDragEnterEvent(QDragEnterEvent*)));
03176     QObject::connect(m_canvas, SIGNAL(sigGotDropEvent(QDropEvent*)), this, SLOT(canvasGotDropEvent(QDropEvent*)));
03177 }
03178 
03179 void KisView::connectCurrentImg()
03180 {
03181     if (m_image) {
03182         connect(m_image, SIGNAL(sigActiveSelectionChanged(KisImageSP)), m_selectionManager, SLOT(imgSelectionChanged(KisImageSP)));
03183         connect(m_image, SIGNAL(sigActiveSelectionChanged(KisImageSP)), this, SLOT(updateCanvas()));
03184         connect(m_image, SIGNAL(sigColorSpaceChanged(KisColorSpace *)), this, SLOT(updateStatusBarProfileLabel()));
03185         connect(m_image, SIGNAL(sigProfileChanged(KisProfile * )), SLOT(profileChanged(KisProfile * )));
03186 
03187         connect(m_image, SIGNAL(sigLayersChanged(KisGroupLayerSP)), SLOT(layersUpdated()));
03188         connect(m_image, SIGNAL(sigMaskInfoChanged()), SLOT(maskUpdated()));
03189         connect(m_image, SIGNAL(sigLayerAdded(KisLayerSP)), SLOT(layersUpdated()));
03190         connect(m_image, SIGNAL(sigLayerRemoved(KisLayerSP, KisGroupLayerSP, KisLayerSP)), SLOT(layersUpdated()));
03191         connect(m_image, SIGNAL(sigLayerMoved(KisLayerSP, KisGroupLayerSP, KisLayerSP)), SLOT(layersUpdated()));
03192         connect(m_image, SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(layersUpdated()));
03193         connect(m_image, SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(updateCanvas()));
03194         connect(m_image, SIGNAL(sigLayerPropertiesChanged(KisLayerSP)), SLOT(layersUpdated()));
03195 
03196         KisConnectPartLayerVisitor v(m_image, this, true);
03197         m_image->rootLayer()->accept(v);
03198         connect(m_image, SIGNAL(sigLayerAdded(KisLayerSP)),
03199                 SLOT(handlePartLayerAdded(KisLayerSP)));
03200 
03201         maskUpdated();
03202 #ifdef HAVE_GL
03203         if (m_OpenGLImageContext != 0) {
03204             connect(m_OpenGLImageContext, SIGNAL(sigImageUpdated(QRect)), SLOT(slotOpenGLImageUpdated(QRect)));
03205             connect(m_OpenGLImageContext, SIGNAL(sigSizeChanged(Q_INT32, Q_INT32)), SLOT(slotImageSizeChanged(Q_INT32, Q_INT32)));
03206         } else
03207 #endif
03208         {
03209             connect(m_image, SIGNAL(sigImageUpdated(QRect)), SLOT(imgUpdated(QRect)));
03210             connect(m_image, SIGNAL(sigSizeChanged(Q_INT32, Q_INT32)), SLOT(slotImageSizeChanged(Q_INT32, Q_INT32)));
03211         }
03212     }
03213 
03214     m_layerBox->setImage(m_image);
03215     m_birdEyeBox->setImage(m_image);
03216 }
03217 
03218 void KisView::disconnectCurrentImg()
03219 {
03220     if (m_image) {
03221         m_image->disconnect(this);
03222         m_layerBox->setImage(0);
03223         m_birdEyeBox->setImage(0);
03224 
03225         KisConnectPartLayerVisitor v(m_image, this, false);
03226         m_image->rootLayer()->accept(v);
03227     }
03228 
03229 #ifdef HAVE_GL
03230     if (m_OpenGLImageContext != 0) {
03231         m_OpenGLImageContext->disconnect(this);
03232     }
03233 #endif
03234 }
03235 
03236 void KisView::handlePartLayerAdded(KisLayerSP layer)
03237 {
03238     KisPartLayer* l = dynamic_cast<KisPartLayer*>(layer.data());
03239     if (!l)
03240         return;
03241 
03242     connect(this, SIGNAL(childActivated(KoDocumentChild*)),
03243             layer, SLOT(childActivated(KoDocumentChild*)));
03244 }
03245 
03246 void KisView::imgUpdated(QRect rc)
03247 {
03248     updateCanvas(rc);
03249 }
03250 
03251 void KisView::slotOpenGLImageUpdated(QRect rc)
03252 {
03253     paintOpenGLView(windowToView(rc));
03254 }
03255 
03256 void KisView::profileChanged(KisProfile *  /*profile*/)
03257 {
03258     updateStatusBarProfileLabel();
03259 }
03260 
03261 void KisView::slotImageSizeChanged(Q_INT32 /*w*/, Q_INT32 /*h*/)
03262 {
03263     resizeEvent(0);
03264     refreshKisCanvas();
03265 }
03266 
03267 void KisView::resizeCurrentImage(Q_INT32 w, Q_INT32 h, bool cropLayers)
03268 {
03269     if (!currentImg()) return;
03270 
03271     currentImg()->resize(w, h, cropLayers);
03272     m_doc->setModified(true);
03273     layersUpdated();
03274 }
03275 
03276 void KisView::scaleCurrentImage(double sx, double sy, KisFilterStrategy *filterStrategy)
03277 {
03278     if (!currentImg()) return;
03279     currentImg()->scale(sx, sy, m_progress, filterStrategy);
03280     m_doc->setModified(true);
03281     layersUpdated();
03282 }
03283 
03284 void KisView::rotateCurrentImage(double radians)
03285 {
03286     if (!currentImg()) return;
03287     currentImg()->rotate(radians, m_progress);
03288     m_doc->setModified(true);
03289     layersUpdated();
03290 }
03291 
03292 void KisView::shearCurrentImage(double angleX, double angleY)
03293 {
03294     if (!currentImg()) return;
03295     currentImg()->shear(angleX, angleY, m_progress);
03296     m_doc->setModified(true);
03297     layersUpdated();
03298 }
03299 
03300 
03301 QPoint KisView::viewToWindow(const QPoint& pt)
03302 {
03303     QPoint converted;
03304 
03305     converted.rx() = static_cast<int>((pt.x() + horzValue()) / zoom());
03306     converted.ry() = static_cast<int>((pt.y() + vertValue()) / zoom());
03307 
03308     return converted;
03309 }
03310 
03311 QPoint KisView::viewToWindow(const QPoint& pt) const
03312 {
03313     QPoint converted;
03314 
03315     converted.rx() = static_cast<int>((pt.x() + horzValue()) / zoom());
03316     converted.ry() = static_cast<int>((pt.y() + vertValue()) / zoom());
03317 
03318     return converted;
03319 }
03320 
03321 KisPoint KisView::viewToWindow(const KisPoint& pt)
03322 {
03323     KisPoint converted;
03324 
03325     converted.setX((pt.x() + horzValue()) / zoom());
03326     converted.setY((pt.y() + vertValue()) / zoom());
03327 
03328     return converted;
03329 }
03330 
03331 QRect KisView::viewToWindow(const QRect& rc)
03332 {
03333     QRect r;
03334 
03335     r.setTopLeft(viewToWindow(rc.topLeft()));
03336     r.setRight((int)(ceil((rc.right() + 1.0 + horzValue()) / zoom()) - 1));
03337     r.setBottom((int)(ceil((rc.bottom() + 1.0 + vertValue()) / zoom()) - 1));
03338 
03339     return r;
03340 }
03341 
03342 KisRect KisView::viewToWindow(const KisRect& rc)
03343 {
03344     KisRect r;
03345     KisPoint p = viewToWindow(KisPoint(rc.x(), rc.y()));
03346     r.setX(p.x());
03347     r.setY(p.y());
03348     r.setWidth(rc.width() / zoom());
03349     r.setHeight(rc.height() / zoom());
03350 
03351     return r;
03352 }
03353 
03354 void KisView::viewToWindow(Q_INT32 *x, Q_INT32 *y)
03355 {
03356     if (x && y) {
03357         QPoint p = viewToWindow(QPoint(*x, *y));
03358         *x = p.x();
03359         *y = p.y();
03360     }
03361 }
03362 
03363 QPoint KisView::windowToView(const QPoint& pt)
03364 {
03365     QPoint p;
03366     p.setX(static_cast<int>(pt.x() * zoom() - horzValue()));
03367     p.setY(static_cast<int>(pt.y() * zoom() - vertValue()));
03368 
03369     return p;
03370 }
03371 
03372 QPoint KisView::windowToView(const QPoint& pt) const
03373 {
03374     QPoint p;
03375     p.setX(static_cast<int>(pt.x() * zoom() - horzValue()));
03376     p.setY(static_cast<int>(pt.y() * zoom() - vertValue()));
03377 
03378     return p;
03379 }
03380 
03381 KisPoint KisView::windowToView(const KisPoint& pt)
03382 {
03383     KisPoint p;
03384     p.setX(pt.x() * zoom() - horzValue());
03385     p.setY(pt.y() * zoom() - vertValue());
03386 
03387     return p;
03388 }
03389 
03390 QRect KisView::windowToView(const QRect& rc)
03391 {
03392     QRect r;
03393 
03394     r.setTopLeft(windowToView(rc.topLeft()));
03395     r.setRight((int)(ceil((rc.right() + 1.0) * zoom()) - horzValue() - 1));
03396     r.setBottom((int)(ceil((rc.bottom() + 1.0) * zoom()) - vertValue() - 1));
03397 
03398     return r;
03399 }
03400 
03401 KisRect KisView::windowToView(const KisRect& rc)
03402 {
03403     KisRect r;
03404     KisPoint p = windowToView(KisPoint(rc.x(), rc.y()));
03405     r.setX(p.x());
03406     r.setY(p.y());
03407     r.setWidth(rc.width() * zoom());
03408     r.setHeight(rc.height() * zoom());
03409 
03410     return r;
03411 }
03412 
03413 void KisView::windowToView(Q_INT32 *x, Q_INT32 *y)
03414 {
03415     if (x && y) {
03416         QPoint p = windowToView(QPoint(*x, *y));
03417         *x = p.x();
03418         *y = p.y();
03419     }
03420 }
03421 
03422 void KisView::guiActivateEvent(KParts::GUIActivateEvent *event)
03423 {
03424     Q_ASSERT(event);
03425 
03426     if (event->activated()) {
03427 
03428         KStatusBar *sb = statusBar();
03429         if (sb) {
03430             sb->show();
03431         }
03432 
03433         if (!m_guiActivateEventReceived) {
03434             m_guiActivateEventReceived = true;
03435             startInitialZoomTimerIfReady();
03436         }
03437     }
03438 
03439     super::guiActivateEvent(event);
03440 }
03441 
03442 bool KisView::eventFilter(QObject *o, QEvent *e)
03443 {
03444     Q_ASSERT(o);
03445     Q_ASSERT(e);
03446 
03447     switch (e->type()) {
03448     case QEvent::TabletMove:
03449     case QEvent::TabletPress:
03450     case QEvent::TabletRelease:
03451     {
03452         QTabletEvent *te = static_cast<QTabletEvent *>(e);
03453         KisInputDevice device;
03454 
03455         switch (te->device()) {
03456         default:
03457         case QTabletEvent::Stylus:
03458         case QTabletEvent::NoDevice:
03459             device = KisInputDevice::stylus();
03460             break;
03461         case QTabletEvent::Puck:
03462             device = KisInputDevice::puck();
03463             break;
03464         case QTabletEvent::Eraser:
03465             device = KisInputDevice::eraser();
03466             break;
03467         }
03468 
03469         setInputDevice(device);
03470 
03471         // We ignore device change due to mouse events for a short duration
03472         // after a tablet event, since these are almost certainly mouse events
03473         // sent to receivers that don't accept the tablet event.
03474         m_tabletEventTimer.start();
03475         break;
03476     }
03477     case QEvent::MouseButtonPress:
03478     case QEvent::MouseMove:
03479     case QEvent::MouseButtonRelease:
03480     {
03481 #ifdef EXTENDED_X11_TABLET_SUPPORT
03482         KisInputDevice device = KisCanvasWidget::findActiveInputDevice();
03483 
03484         if (device != KisInputDevice::mouse()) {
03485             setInputDevice(device);
03486             m_tabletEventTimer.start();
03487         } else
03488 #endif
03489         {
03490             if (currentInputDevice() != KisInputDevice::mouse() && m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) {
03491                 setInputDevice(KisInputDevice::mouse());
03492             }
03493         }
03494         break;
03495     }
03496     case QEvent::KeyPress:
03497     case QEvent::KeyRelease:
03498     {
03499         if (m_canvas->cursorIsOverCanvas()) {
03500             m_canvas->handleKeyEvent(e);
03501             return true;
03502         }
03503         break;
03504     }
03505 #if 0
03506     // This code is unnecessary now that there's an application event filter
03507     // This eventFilter is called for all widgets already, no need to install event filters multiple times
03508     // Even worse: with multiple views, they would all install event filters on each other's widgets,
03509     // due to the qapp event filter triggering in all views!
03510     case QEvent::ChildInserted:
03511     {
03512         QChildEvent *childEvent = static_cast<QChildEvent *>(e);
03513         QObject *child = childEvent->child();
03514         if ( child->isWidgetType() ) {
03515 
03516             child->installEventFilter(this);
03517 
03518             QObjectList *objectList = child->queryList("QWidget");
03519             QObjectListIt it(*objectList);
03520             QObject *obj;
03521             while ((obj = it.current()) != 0) {
03522                 obj->installEventFilter(this);
03523                 ++it;
03524             }
03525             delete objectList;
03526         }
03527     }
03528 #endif
03529     default:
03530         // Ignore
03531         break;
03532     }
03533 
03534 #if 0
03535     if ((o == m_hRuler || o == m_vRuler) && (e->type() == QEvent::MouseMove || e->type() == QEvent::MouseButtonRelease)) {
03536         QMouseEvent *me = dynamic_cast<QMouseEvent*>(e);
03537         QPoint pt = mapFromGlobal(me->globalPos());
03538         KisImageSP img = currentImg();
03539         KisGuideMgr *mgr;
03540 
03541         if (!img)
03542             return super::eventFilter(o, e);
03543 
03544         mgr = img->guides();
03545 
03546         if (e->type() == QEvent::MouseMove && (me->state() & Qt::LeftButton)) {
03547             bool flag = geometry().contains(pt);
03548             KisGuideSP gd;
03549 
03550             if (m_currentGuide == 0 && flag) {
03551                 // No guide is being edited and moving mouse over the canvas.
03552                 // Create a new guide.
03553                 enterEvent(0);
03554                 eraseGuides();
03555                 mgr->unselectAll();
03556 
03557                 if (o == m_vRuler)
03558                     gd = mgr->add((pt.x() - m_vRuler->width() + horzValue()) / zoom(), Qt::Vertical);
03559                 else
03560                     gd = mgr->add((pt.y() - m_hRuler->height() + vertValue()) / zoom(), Qt::Horizontal);
03561 
03562                 m_currentGuide = gd;
03563                 mgr->select(gd);
03564                 m_lastGuidePoint = mapToScreen(pt);
03565             } else if (m_currentGuide) {
03566                 if (flag) {
03567                     // moved an existing guide.
03568                     KisMoveEvent kme(currentInputDevice(), pt, me->globalPos(), PRESSURE_DEFAULT, 0, 0, me->state());
03569                     canvasGotMoveEvent(&kme);
03570                 } else {
03571                     //  moved a guide out of the frame, destroy it
03572                     leaveEvent(0);
03573                     eraseGuides();
03574                     mgr->remove(m_currentGuide);
03575                     paintGuides();
03576                     m_currentGuide = 0;
03577                 }
03578             }
03579         } else if (e->type() == QEvent::MouseButtonRelease && m_currentGuide) {
03580             eraseGuides();
03581             mgr->unselect(m_currentGuide);
03582             paintGuides();
03583             m_currentGuide = 0;
03584             enterEvent(0);
03585             KisMoveEvent kme(currentInputDevice(), pt, me->globalPos(), PRESSURE_DEFAULT, 0, 0, Qt::NoButton);
03586             canvasGotMoveEvent(&kme);
03587         }
03588     }
03589 #endif
03590 
03591     return super::eventFilter(o, e);
03592 }
03593 
03594 #if 0
03595 void KisView::eraseGuides()
03596 {
03597     KisImageSP img = currentImg();
03598 
03599     if (img) {
03600         KisGuideMgr *mgr = img->guides();
03601 
03602         if (mgr)
03603             mgr->erase(&m_canvasPixmap, this, horzValue(), vertValue(), zoom());
03604     }
03605 }
03606 
03607 void KisView::paintGuides()
03608 {
03609     KisImageSP img = currentImg();
03610 
03611     if (img) {
03612         KisGuideMgr *mgr = img->guides();
03613 
03614         if (mgr)
03615             mgr->paint(&m_canvasPixmap, this, horzValue(), vertValue(), zoom());
03616     }
03617 }
03618 
03619 void KisView::updateGuides()
03620 {
03621     eraseGuides();
03622     paintGuides();
03623 }
03624 #endif
03625 
03626 //void KisView::viewGuideLines()
03627 //{
03628 //}
03629 
03630 QPoint KisView::mapToScreen(const QPoint& pt)
03631 {
03632     QPoint converted;
03633 
03634     converted.rx() = pt.x() + horzValue();
03635     converted.ry() = pt.y() + vertValue();
03636     return converted;
03637 }
03638 
03639 void KisView::attach(KisCanvasObserver *observer)
03640 {
03641     Q_ASSERT(observer);
03642     if (observer)
03643         m_observers.push_back(observer);
03644 }
03645 
03646 void KisView::detach(KisCanvasObserver *observer)
03647 {
03648     Q_ASSERT(observer);
03649     if (observer) {
03650         vKisCanvasObserver_it it = std::find(m_observers.begin(), m_observers.end(), observer);
03651 
03652         if (it != m_observers.end())
03653             m_observers.erase(it);
03654     }
03655 }
03656 
03657 void KisView::notifyObservers()
03658 {
03659     for (vKisCanvasObserver_it it = m_observers.begin(); it != m_observers.end(); ++it) {
03660         (*it)->update(this);
03661     }
03662 }
03663 
03664 KisImageSP KisView::currentImg() const
03665 {
03666     return m_image;
03667 }
03668 
03669 void KisView::setCurrentImage(KisImageSP image)
03670 {
03671     if(!image) return;
03672 
03673     disconnectCurrentImg();
03674     m_image = image;
03675 
03676     KisConfig cfg;
03677 
03678 #ifdef HAVE_GL
03679     if (cfg.useOpenGL()) {
03680         m_OpenGLImageContext = KisOpenGLImageContext::getImageContext(image, monitorProfile());
03681         m_canvas->createOpenGLCanvas(m_OpenGLImageContext->sharedContextWidget());
03682     }
03683 #endif
03684     connectCurrentImg();
03685     m_layerBox->setImage(currentImg());
03686 
03687     zoomAroundPoint(0, 0, 1.0);
03688 
03689     if (!currentImg())
03690         layersUpdated();
03691 
03692     imgUpdateGUI();
03693 
03694     image->blockSignals(false);
03695 }
03696 
03697 KisColor KisView::bgColor() const
03698 {
03699     return m_bg;
03700 }
03701 
03702 KisColor KisView::fgColor() const
03703 {
03704     return m_fg;
03705 }
03706 
03707 KisBrush *KisView::currentBrush() const
03708 {
03709     return m_brush;
03710 }
03711 
03712 KisPattern *KisView::currentPattern() const
03713 {
03714     return m_pattern;
03715 }
03716 
03717 KisGradient *KisView::currentGradient() const
03718 {
03719     return m_gradient;
03720 }
03721 
03722 KisID KisView::currentPaintop() const
03723 {
03724     return m_paintop;
03725 }
03726 
03727 const KisPaintOpSettings *KisView::currentPaintopSettings() const
03728 {
03729     return m_paintopSettings;
03730 }
03731 
03732 double KisView::zoomFactor() const
03733 {
03734     return zoom();
03735 }
03736 
03737 KisUndoAdapter *KisView::undoAdapter() const
03738 {
03739     return m_adapter;
03740 }
03741 
03742 KisCanvasController *KisView::canvasController() const
03743 {
03744     return const_cast<KisCanvasController*>(static_cast<const KisCanvasController*>(this));
03745 }
03746 
03747 KisToolControllerInterface *KisView::toolController() const
03748 {
03749     return const_cast<KisToolControllerInterface*>(static_cast<const KisToolControllerInterface*>(m_toolManager));
03750 }
03751 
03752 KisDoc *KisView::document() const
03753 {
03754     return m_doc;
03755 }
03756 
03757 KisProgressDisplayInterface *KisView::progressDisplay() const
03758 {
03759     return m_progress;
03760 }
03761 
03762 QCursor KisView::setCanvasCursor(const QCursor & cursor)
03763 {
03764     QCursor oldCursor = m_canvas->cursor();
03765     QCursor newCursor;
03766 
03767     KisConfig cfg;
03768 
03769     switch (cfg.cursorStyle()) {
03770     case CURSOR_STYLE_TOOLICON:
03771         newCursor = cursor;
03772         break;
03773     case CURSOR_STYLE_CROSSHAIR:
03774         newCursor = KisCursor::crossCursor();
03775         break;
03776     case CURSOR_STYLE_POINTER:
03777         newCursor = KisCursor::arrowCursor();
03778         break;
03779     case CURSOR_STYLE_OUTLINE:
03780         newCursor = cursor;
03781         break;
03782     default:
03783         newCursor = cursor;
03784     }
03785 
03786     m_canvas->setCursor(newCursor);
03787     return oldCursor;
03788 }
03789 
03790 float KisView::HDRExposure() const
03791 {
03792     return m_HDRExposure;
03793 }
03794 
03795 void KisView::setHDRExposure(float exposure)
03796 {
03797     if (exposure != m_HDRExposure) {
03798         m_HDRExposure = exposure;
03799         notifyObservers();
03800         updateCanvas();
03801     }
03802 }
03803 
03804 void KisView::createDockers()
03805 {
03806 
03807     m_birdEyeBox = new KisBirdEyeBox(this);
03808     m_birdEyeBox->setCaption(i18n("Overview"));
03809     m_paletteManager->addWidget( m_birdEyeBox, "birdeyebox", krita::CONTROL_PALETTE);
03810 
03811     m_hsvwidget = new KoHSVWidget(this, "hsv");
03812     m_hsvwidget->setCaption(i18n("HSV"));
03813 
03814     connect(m_hsvwidget, SIGNAL(sigFgColorChanged(const QColor &)), this, SLOT(slotSetFGQColor(const QColor &)));
03815     connect(m_hsvwidget, SIGNAL(sigBgColorChanged(const QColor &)), this, SLOT(slotSetBGQColor(const QColor &)));
03816     connect(this, SIGNAL(sigFGQColorChanged(const QColor &)), m_hsvwidget, SLOT(setFgColor(const QColor &)));
03817     connect(this, SIGNAL(sigBGQColorChanged(const QColor &)), m_hsvwidget, SLOT(setBgColor(const QColor &)));
03818     m_paletteManager->addWidget( m_hsvwidget, "hsvwidget", krita::COLORBOX, 0, PALETTE_DOCKER, true);
03819 
03820     m_rgbwidget = new KoRGBWidget(this, "rgb");
03821     m_rgbwidget->setCaption(i18n("RGB"));
03822     connect(m_rgbwidget, SIGNAL(sigFgColorChanged(const QColor &)), this, SLOT(slotSetFGQColor(const QColor &)));
03823     connect(m_rgbwidget, SIGNAL(sigBgColorChanged(const QColor &)), this, SLOT(slotSetBGQColor(const QColor &)));
03824     connect(this, SIGNAL(sigFGQColorChanged(const QColor &)), m_rgbwidget, SLOT(setFgColor(const QColor &)));
03825     connect(this, SIGNAL(sigBGQColorChanged(const QColor &)), m_rgbwidget, SLOT(setBgColor(const QColor &)));
03826     m_paletteManager->addWidget( m_rgbwidget, "rgbwidget", krita::COLORBOX);
03827 
03828     m_graywidget = new KoGrayWidget(this, "gray");
03829     m_graywidget->setCaption(i18n("Gray"));
03830     connect(m_graywidget, SIGNAL(sigFgColorChanged(const QColor &)), this, SLOT(slotSetFGQColor(const QColor &)));
03831     connect(m_graywidget, SIGNAL(sigBgColorChanged(const QColor &)), this, SLOT(slotSetBGQColor(const QColor &)));
03832     connect(this, SIGNAL(sigFGQColorChanged(const QColor &)), m_graywidget, SLOT(setFgColor(const QColor &)));
03833     connect(this, SIGNAL(sigBGQColorChanged(const QColor &)), m_graywidget, SLOT(setBgColor(const QColor &)));
03834     m_paletteManager->addWidget( m_graywidget, "graywidget", krita::COLORBOX);
03835 
03836     //make sure the color chooser get right default values
03837     emit sigFGQColorChanged(m_fg.toQColor());
03838     emit sigBGQColorChanged(m_bg.toQColor());
03839 
03840     m_palettewidget = new KisPaletteWidget(this);
03841     m_palettewidget->setCaption(i18n("Palettes"));
03842     connect(m_palettewidget, SIGNAL(colorSelected(const QColor &)),
03843             this, SLOT(slotSetFGQColor(const QColor &)));
03844     // No BGColor or reverse slotFGChanged->palette connections, since that's not useful here
03845 
03846     KisResourceServerBase* rServer;
03847     rServer = KisResourceServerRegistry::instance()->get("PaletteServer");
03848     QValueList<KisResource*> resources = rServer->resources();
03849     QValueList<KisResource*>::iterator it;
03850     for ( it = resources.begin(); it != resources.end(); ++it ) {
03851         m_palettewidget->slotAddPalette( *it );
03852     }
03853     connect(m_palettewidget, SIGNAL(colorSelected(const KisColor &)), this, SLOT(slotSetFGColor(const KisColor &)));
03854     m_paletteManager->addWidget( m_palettewidget, "palettewidget", krita::COLORBOX, 10, PALETTE_DOCKER, true);
03855 }
03856 
03857 QPoint KisView::applyViewTransformations(const QPoint& p) const {
03858     QPoint point(windowToView(p));
03859 
03860     if (m_hRuler->isShown())
03861         point.ry() += m_hRuler->height();
03862     if (m_vRuler -> isShown())
03863         point.rx() += m_vRuler->width();
03864 
03865     return point;
03866 }
03867 
03868 QPoint KisView::reverseViewTransformations(const QPoint& p) const {
03869     // Since we now zoom ourselves, the only thing super::~ does is nothing anymore.
03870     // Hence, zoom ourselves, like super would
03871     // viewToWindow doesn't take the rulers into account, do that ourselves
03872     QPoint point(p);
03873     if (m_hRuler -> isShown())
03874         point.ry() -= m_hRuler -> height();
03875     if (m_vRuler -> isShown())
03876         point.rx() -= m_vRuler -> width();
03877 
03878     return viewToWindow(point);
03879 }
03880 
03881 void KisView::canvasAddChild(KoViewChild *child) {
03882     super::canvasAddChild(child);
03883     connect(this, SIGNAL(viewTransformationsChanged()), child, SLOT(reposition()));
03884     m_vScroll->raise();
03885     m_hScroll->raise();
03886     m_vScroll->raise();
03887     m_hRuler->raise();
03888     m_vRuler->raise();
03889 }
03890 
03891 void KisView::slotLoadingFinished()
03892 {
03893     // Set the current image for real now everything is ready to go.
03894     setCurrentImage(document()->currentImage());
03895     m_paletteManager->showWidget( "layerbox" );
03896     m_canvas->show();
03897     disconnect(document(), SIGNAL(loadingFinished()), this, SLOT(slotLoadingFinished()));
03898 
03899     m_imageLoaded = true;
03900     startInitialZoomTimerIfReady();
03901 }
03902 
03903 void KisView::startInitialZoomTimerIfReady()
03904 {
03905     if (m_imageLoaded && m_showEventReceived && m_guiActivateEventReceived) {
03906         m_initialZoomTimer.start(250, true);
03907     }
03908 }
03909 
03910 void KisView::slotInitialZoomTimeout()
03911 {
03912     Q_ASSERT(!m_paintViewEnabled);
03913 
03914     m_paintViewEnabled = true;
03915     setInitialZoomLevel();
03916 }
03917 
03918 
03919 void KisView::slotCreateMask() {
03920     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03921     if (!layer)
03922         return;
03923 
03924     KNamedCommand *cmd = layer->createMaskCommand();
03925     cmd->execute();
03926     if (undoAdapter() && undoAdapter()->undo()) {
03927         undoAdapter()->addCommand(cmd);
03928     }
03929 }
03930 
03931 void KisView::slotMaskFromSelection() {
03932     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03933     if (!layer)
03934         return;
03935 
03936     KNamedCommand *cmd = layer->maskFromSelectionCommand();
03937     cmd->execute();
03938     if (undoAdapter() && undoAdapter()->undo()) {
03939         undoAdapter()->addCommand(cmd);
03940     }
03941 }
03942 
03943 void KisView::slotMaskToSelection() {
03944     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03945     if (!layer)
03946         return;
03947 
03948     KNamedCommand *cmd = layer->maskToSelectionCommand();
03949     cmd->execute();
03950     if (undoAdapter() && undoAdapter()->undo()) {
03951         undoAdapter()->addCommand(cmd);
03952     }
03953 }
03954 
03955 void KisView::slotApplyMask() {
03956     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03957     if (!layer)
03958         return;
03959 
03960     KNamedCommand *cmd = layer->applyMaskCommand();
03961     cmd->execute();
03962     if (undoAdapter() && undoAdapter()->undo()) {
03963         undoAdapter()->addCommand(cmd);
03964     }
03965 }
03966 
03967 void KisView::slotRemoveMask() {
03968     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03969     if (!layer)
03970         return;
03971 
03972     KNamedCommand *cmd = layer->removeMaskCommand();
03973     cmd->execute();
03974     if (undoAdapter() && undoAdapter()->undo()) {
03975         undoAdapter()->addCommand(cmd);
03976     }
03977 }
03978 
03979 void KisView::slotEditMask() {
03980     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03981     if (!layer)
03982         return;
03983 
03984     layer->setEditMask(m_editMask->isChecked());
03985 }
03986 
03987 void KisView::slotShowMask() {
03988     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03989     if (!layer)
03990         return;
03991 
03992     layer->setRenderMask(m_showMask->isChecked());
03993 }
03994 
03995 void KisView::maskUpdated() {
03996     KisPaintLayer* layer = dynamic_cast<KisPaintLayer*>(currentImg()->activeLayer().data());
03997     if (!layer) {
03998         m_createMask->setEnabled(false);
03999         m_applyMask->setEnabled(false);
04000         m_removeMask->setEnabled(false);
04001         m_editMask->setEnabled(false);
04002         m_showMask->setEnabled(false);
04003         return;
04004     }
04005     m_createMask->setEnabled(!layer->hasMask());
04006     m_maskFromSelection->setEnabled(true); // Perhaps also update this to false when no selection?
04007     m_maskToSelection->setEnabled(layer->hasMask());
04008     m_applyMask->setEnabled(layer->hasMask());
04009     m_removeMask->setEnabled(layer->hasMask());
04010 
04011     m_editMask->setEnabled(layer->hasMask());
04012     m_editMask->setChecked(layer->editMask());
04013     m_showMask->setEnabled(layer->hasMask());
04014     m_showMask->setChecked(layer->renderMask());
04015 }
04016 
04017 #include "kis_view.moc"
04018 
KDE Home | KDE Accessibility Home | Description of Access Keys