00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <algorithm>
00026 #include <cmath>
00027
00028
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
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
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
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
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
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
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
00167
00168
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
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
00250 #ifdef Q_WS_X11
00251 KisCanvasWidget::initX11Support();
00252 #endif
00253
00254
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
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
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
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;
00608 m_imgResizeToLayer = new KAction(i18n("Resize Image to Size of Current Layer"), 0, this, SLOT(imgResizeToActiveLayer()), actionCollection(), "resizeimgtolayer");
00609
00610
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
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
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
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
00678
00679
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
00686
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
00704
00705
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
00717 drawW -= scrollBarExtent;
00718 if (drawW < docW)
00719
00720 drawH -= scrollBarExtent;
00721 } else if (drawW < docW) {
00722
00723 drawH -= scrollBarExtent;
00724 if (drawH < docH)
00725
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
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
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
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
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
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
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
00828 srcX = 0;
00829 dstX = m_canvasXOffset - oldCanvasXOffset;
00830 srcWidth = oldCanvasWidth;
00831 } else {
00832
00833 srcX = oldCanvasXOffset - m_canvasXOffset;
00834 dstX = 0;
00835 srcWidth = newCanvasWidth;
00836 }
00837
00838 if (oldCanvasYOffset <= m_canvasYOffset) {
00839
00840 srcY = 0;
00841 dstY = m_canvasYOffset - oldCanvasYOffset;
00842 srcHeight = oldCanvasHeight;
00843 } else {
00844
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
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
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
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
01162
01163 glBindTexture(GL_TEXTURE_2D, 0);
01164
01165
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
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
01244
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
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
01413 m_canvas->setUpdatesEnabled(false);
01414 m_hScroll->setUpdatesEnabled(false);
01415 m_vScroll->setUpdatesEnabled(false);
01416
01417 if (x < 0 || y < 0) {
01418
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
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
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
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
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
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
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
02277
02278
02279
02280
02281
02282
02283
02284
02285
02286
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298
02299
02300
02301
02302
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
02319
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
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
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
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
02441
02442
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
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
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
02511
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
02525 m_panning = true;
02526 m_oldTool = m_toolManager->currentTool();
02527 m_toolManager->setCurrentTool( "tool_pan" );
02528 }
02529 else {
02530
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
02551
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
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
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
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;
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
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
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
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
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 * )
03257 {
03258 updateStatusBarProfileLabel();
03259 }
03260
03261 void KisView::slotImageSizeChanged(Q_INT32 , Q_INT32 )
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
03472
03473
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
03507
03508
03509
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
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
03552
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
03568 KisMoveEvent kme(currentInputDevice(), pt, me->globalPos(), PRESSURE_DEFAULT, 0, 0, me->state());
03569 canvasGotMoveEvent(&kme);
03570 } else {
03571
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
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
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
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
03870
03871
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
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);
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