/* This file is part of KimageShop^WKrayon^WChalk * * Copyright (c) 1999 Matthias Elter * 1999 Michael Koch * 1999 Carsten Pfeiffer * 2002 Patrick Julien * 2003-2005 Boudewijn Rempt * 2004 Clarence Dang * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include // TQt #include #include #include #include #include #include #include #include #include #include #include #include #include #include // KDE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // KOffice #include #include #include #include #include #include #include #include #include #include // Local #include "kis_brush.h" #include "kis_button_press_event.h" #include "kis_button_release_event.h" #include "kis_canvas.h" #include "kis_canvas_painter.h" #include "kis_color.h" #include "kis_colorspace_factory_registry.h" #include "kis_config.h" #include "kis_controlframe.h" #include "kis_cursor.h" #include "kis_doc.h" #include "kis_double_click_event.h" #include "kis_factory.h" #include "kis_filter_strategy.h" #include "kis_gradient.h" #include "kis_group_layer.h" #include "kis_adjustment_layer.h" #include "kis_paint_device.h" #include "kis_tool_freehand.h" //#include "kis_guide.h" #include "kis_layerbox.h" #include "kis_import_catcher.h" #include "kis_layer.h" #include "kis_paint_layer.h" #include "kis_move_event.h" #include "kis_paint_device.h" #include "kis_painter.h" #include "kis_paintop_registry.h" #include "kis_part_layer.h" #include "kis_part_layer_handler.h" #include "kis_pattern.h" #include "kis_profile.h" #include "kis_rect.h" #include "kis_resource.h" #include "kis_palette.h" #include "kis_ruler.h" #include "kis_selection.h" #include "KoToolBox.h" #include "kis_tool.h" #include "kis_tool_manager.h" #include "kis_transaction.h" #include "kis_selected_transaction.h" #include "kis_types.h" #include "kis_undo_adapter.h" #include "kis_view.h" #include "kis_view_iface.h" #include "kis_label_progress.h" #include "kis_opengl_image_context.h" #include "kis_background.h" #include "kis_paint_device_action.h" #include "kis_filter_configuration.h" #include "kis_transform_worker.h" #include "kis_shear_visitor.h" #include #include #include "kis_icon_item.h" #include "kis_palette_widget.h" #include "kis_birdeye_box.h" #include "kis_color.h" #include "kis_factory.h" // Dialog boxes #include "kis_dlg_new_layer.h" #include "kis_dlg_layer_properties.h" #include "kis_dlg_preferences.h" #include "kis_dlg_image_properties.h" #include "kis_dlg_adjustment_layer.h" #include "kis_dlg_adj_layer_props.h" // Action managers #include "kis_selection_manager.h" #include "kis_filter_manager.h" #include "kis_grid_manager.h" #include "kis_perspective_grid_manager.h" #include "kis_custom_palette.h" #include "wdgpalettechooser.h" #include // Time in ms that must pass after a tablet event before a mouse event is allowed to // change the input device to the mouse. This is needed because mouse events are always // sent to a receiver if it does not accept the tablet event. #define MOUSE_CHANGE_EVENT_DELAY 100 KisView::KisView(KisDoc *doc, KisUndoAdapter *adapter, TQWidget *parent, const char *name) : super(doc, parent, name) , KXMLGUIBuilder( shell() ) , m_panning( false ) , m_oldTool( 0 ) , m_doc( doc ) , m_canvas( 0 ) , m_partHandler( 0 ) , m_gridManager( 0 ) , m_perspectiveGridManager( 0 ) , m_selectionManager( 0 ) , m_filterManager( 0 ) , m_paletteManager( 0 ) , m_toolManager( 0 ) , m_actLayerVis( false ) , m_hRuler( 0 ) , m_vRuler( 0 ) , m_imgFlatten( 0 ) , m_imgMergeLayer( 0 ) , m_imgRename( 0 ) , m_imgResizeToLayer( 0 ) , m_imgScan( 0 ) , m_actionPartLayer( 0 ) , m_layerAdd( 0 ) , m_layerBottom( 0 ) , m_layerDup( 0 ) , m_layerHide( 0 ) , m_layerLower( 0 ) , m_layerProperties( 0 ) , m_layerRaise( 0 ) , m_layerRm( 0 ) , m_layerSaveAs( 0 ) , m_layerTop( 0 ) , m_zoomIn( 0 ) , m_zoomOut( 0 ) , m_actualPixels( 0 ) , m_actualSize( 0 ) , m_fitToCanvas( 0 ) , m_fullScreen( 0 ) , m_imgProperties( 0 ) , m_RulerAction( 0 ) , m_guideAction( 0 ) , m_dcop( 0 ) , m_hScroll( 0 ) , m_vScroll( 0 ) , m_scrollX( 0 ) , m_scrollY( 0 ) , m_canvasXOffset( 0) , m_canvasYOffset( 0) , m_paintViewEnabled( false ) , m_guiActivateEventReceived( false ) , m_showEventReceived( false ) , m_imageLoaded( false ) // , m_currentGuide( 0 ) , m_adapter( adapter ) , m_statusBarZoomLabel( 0 ) , m_statusBarSelectionLabel( 0 ) , m_statusBarProfileLabel( 0 ) , m_progress( 0 ) , m_layerBox( 0 ) , m_toolBox( 0 ) , m_brush( 0 ) , m_pattern( 0 ) , m_gradient( 0 ) , m_toolIsPainting( false ) , m_monitorProfile( 0 ) , m_HDRExposure( 0 ) { Q_ASSERT(doc); Q_ASSERT(adapter); Q_ASSERT(parent); KisConfig cfg; m_currentColorChooserDisplay = KisID("BLA"); setFocusPolicy( TQ_StrongFocus ); // Must come before input devices are referenced as this detects them. #ifdef Q_WS_X11 KisCanvasWidget::initX11Support(); #endif // Install event filter before we create any child widgets so they can see // the tablet events. tqApp->installEventFilter(this); m_tabletEventTimer.start(); m_inputDevice = KisInputDevice::mouse(); connect(&m_initialZoomTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotInitialZoomTimeout())); m_paletteManager = new KoPaletteManager(this, actionCollection(), "Chalk palette manager"); if (cfg.fixDockerWidth()) m_paletteManager->setFixedWidth( 360 ); m_paletteManager->createPalette( chalk::CONTROL_PALETTE, i18n("Control box")); m_paletteManager->createPalette( chalk::COLORBOX, i18n("Colors")); m_paletteManager->createPalette( chalk::LAYERBOX, i18n("Layers")); m_selectionManager = new KisSelectionManager(this, doc); m_filterManager = new KisFilterManager(this, doc); m_toolManager = new KisToolManager(canvasSubject(), getCanvasController()); m_gridManager = new KisGridManager(this); m_perspectiveGridManager = new KisPerspectiveGridManager(this); // This needs to be set before the dockers are created. m_image = m_doc->currentImage(); KisColorSpace * cs = KisMetaRegistry::instance()->csRegistry()->getRGB8(); m_fg = KisColor(TQt::black, cs); m_bg = KisColor(TQt::white, cs); createDockers(); setInstance(KisFactory::instance(), false); setClientBuilder( this ); if (!doc->isReadWrite()) setXMLFile("chalk_readonly.rc"); else setXMLFile("chalk.rc"); KStdAction::keyBindings( mainWindow()->guiFactory(), TQT_SLOT( configureShortcuts() ), actionCollection() ); createLayerBox(); setupCanvas(); m_canvas->hide(); setupRulers(); setupScrollBars(); setupStatusBar(); setupActions(); dcopObject(); connect(TQT_TQOBJECT(this), TQT_SIGNAL(autoScroll(const TQPoint &)), TQT_SLOT(slotAutoScroll(const TQPoint &))); setMouseTracking(true); resetMonitorProfile(); layersUpdated(); m_brushesAndStuffToolBar = new KisControlFrame(mainWindow(), this); // Load all plugins KTrader::OfferList offers = KTrader::self()->query(TQString::fromLatin1("Chalk/ViewPlugin"), TQString::fromLatin1("(Type == 'Service') and " "([X-Chalk-Version] == 2)")); KTrader::OfferList::ConstIterator iter; for(iter = offers.begin(); iter != offers.end(); ++iter) { KService::Ptr service = *iter; int errCode = 0; KParts::Plugin* plugin = KParts::ComponentFactory::createInstanceFromService ( service, TQT_TQOBJECT(this), 0, TQStringList(), &errCode); if ( plugin ) { kdDebug(41006) << "found plugin " << service->property("Name").toString() << "\n"; insertChildClient(plugin); } else { kdDebug(41006) << "found plugin " << service->property("Name").toString() << ", " << errCode << "\n"; if( errCode == KParts::ComponentFactory::ErrNoLibrary) { kdWarning(41006) << " Error loading plugin was : ErrNoLibrary " << KLibLoader::self()->lastErrorMessage() << endl; } } } if(!doc->isLoading()) { slotLoadingFinished(); } else { connect(doc, TQT_SIGNAL(loadingFinished()), TQT_TQOBJECT(this), TQT_SLOT(slotLoadingFinished())); } setFocus(); } KisView::~KisView() { KisConfig cfg; cfg.setShowRulers( m_RulerAction->isChecked() ); delete m_dcop; delete m_paletteManager; delete m_selectionManager; delete m_filterManager; delete m_toolManager; } static TQt::Dock stringToDock( const TQString& attrPosition ) { KToolBar::Dock dock = KToolBar::DockTop; if ( !attrPosition.isEmpty() ) { if ( attrPosition == "top" ) dock = TQt::DockTop; else if ( attrPosition == "left" ) dock = TQt::DockLeft; else if ( attrPosition == "right" ) dock = TQt::DockRight; else if ( attrPosition == "bottom" ) dock = TQt::DockBottom; else if ( attrPosition == "floating" ) dock = TQt::DockTornOff; else if ( attrPosition == "flat" ) dock = TQt::DockMinimized; } return dock; } TQWidget * KisView::createContainer( TQWidget *parent, int index, const TQDomElement &element, int &id ) { if( element.attribute( "name" ) == "ToolBox" ) { m_toolBox = new KoToolBox(mainWindow(), "ToolBox", KisFactory::instance(), NUMBER_OF_TOOLTYPES); m_toolBox->setLabel(i18n("Chalk")); m_toolManager->setUp(m_toolBox, m_paletteManager, actionCollection()); Dock dock = stringToDock( element.attribute( "position" ).lower() ); mainWindow()->addDockWindow( m_toolBox, dock, false); mainWindow()->moveDockWindow( m_toolBox, dock, false, 0, 0 ); } return KXMLGUIBuilder::createContainer( parent, index, element, id ); } void KisView::removeContainer( TQWidget *container, TQWidget *parent, TQDomElement &element, int id ) { Q_ASSERT(container); if( shell() && container == m_toolBox ) { delete m_toolBox; m_toolManager->youAintGotNoToolBox(); } else { KXMLGUIBuilder::removeContainer( container, parent, element, id ); } } KoPaletteManager * KisView::paletteManager() { if (!m_paletteManager) { m_paletteManager = new KoPaletteManager(this, actionCollection(), "Chalk palette manager"); TQ_CHECK_PTR(m_paletteManager); } return m_paletteManager; } void KisView::createLayerBox() { m_layerBox = new KisLayerBox(this); m_layerBox->setCaption(i18n("Layers")); connect(m_layerBox, TQT_SIGNAL(sigRequestLayer(KisGroupLayerSP, KisLayerSP)), TQT_TQOBJECT(this), TQT_SLOT(addLayer(KisGroupLayerSP, KisLayerSP))); connect(m_layerBox, TQT_SIGNAL(sigRequestGroupLayer(KisGroupLayerSP, KisLayerSP)), TQT_TQOBJECT(this), TQT_SLOT(addGroupLayer(KisGroupLayerSP, KisLayerSP))); connect(m_layerBox, TQT_SIGNAL(sigRequestAdjustmentLayer(KisGroupLayerSP, KisLayerSP)), TQT_TQOBJECT(this), TQT_SLOT(addAdjustmentLayer(KisGroupLayerSP, KisLayerSP))); connect(m_layerBox, TQT_SIGNAL(sigRequestPartLayer(KisGroupLayerSP, KisLayerSP, const KoDocumentEntry&)), TQT_TQOBJECT(this), TQT_SLOT(addPartLayer(KisGroupLayerSP, KisLayerSP, const KoDocumentEntry&))); connect(m_layerBox, TQT_SIGNAL(sigRequestLayerProperties(KisLayerSP)), TQT_TQOBJECT(this), TQT_SLOT(showLayerProperties(KisLayerSP))); connect(m_layerBox, TQT_SIGNAL(sigOpacityChanged(int, bool)), TQT_TQOBJECT(this), TQT_SLOT(layerOpacity(int, bool))); connect(m_layerBox, TQT_SIGNAL(sigOpacityFinishedChanging(int, int)), TQT_TQOBJECT(this), TQT_SLOT(layerOpacityFinishedChanging(int, int))); connect(m_layerBox, TQT_SIGNAL(sigItemComposite(const KisCompositeOp&)), TQT_TQOBJECT(this), TQT_SLOT(layerCompositeOp(const KisCompositeOp&))); paletteManager()->addWidget(m_layerBox, "layerbox", chalk::LAYERBOX, 0); } DCOPObject* KisView::dcopObject() { if (!m_dcop) { m_dcop = new KisViewIface(this); TQ_CHECK_PTR(m_dcop); } return m_dcop; } void KisView::setupScrollBars() { m_scrollX = 0; m_scrollY = 0; m_vScroll = new TQScrollBar(Qt::Vertical, this); TQ_CHECK_PTR(m_vScroll); m_hScroll = new TQScrollBar(Qt::Horizontal, this); TQ_CHECK_PTR(m_hScroll); m_vScroll->setGeometry(width() - 16, 20, 16, height() - 36); m_hScroll->setGeometry(20, height() - 16, width() - 36, 16); m_hScroll->setValue(0); m_vScroll->setValue(0); TQObject::connect(m_vScroll, TQT_SIGNAL(valueChanged(int)), TQT_TQOBJECT(this), TQT_SLOT(scrollV(int))); TQObject::connect(m_hScroll, TQT_SIGNAL(valueChanged(int)), TQT_TQOBJECT(this), TQT_SLOT(scrollH(int))); } void KisView::setupRulers() { m_hRuler = new KisRuler(Qt::Horizontal, this); TQ_CHECK_PTR(m_hRuler); m_vRuler = new KisRuler(Qt::Vertical, this); TQ_CHECK_PTR(m_vRuler); m_hRuler->setGeometry(20, 0, width() - 20, 20); m_vRuler->setGeometry(0, 20, 20, height() - 20); if (statusBar()) { m_hRuler->installEventFilter(this); m_vRuler->installEventFilter(this); } } #define EPSILON 1e-6 void KisView::updateStatusBarZoomLabel () { if (zoom() < 1 - EPSILON) { m_statusBarZoomLabel->setText(i18n("Zoom %1%").arg(zoom() * 100, 0, 'g', 4)); } else { m_statusBarZoomLabel->setText(i18n("Zoom %1%").arg(zoom() * 100, 0, 'f', 0)); } m_statusBarZoomLabel->setMaximumWidth(m_statusBarZoomLabel->fontMetrics().width(i18n("Zoom %1%").arg("0.8888 "))); } void KisView::updateStatusBarSelectionLabel() { if (m_statusBarSelectionLabel == 0) { return; } KisImageSP img = currentImg(); if (img) { KisPaintDeviceSP dev = img->activeDevice(); if (dev) { if (dev->hasSelection()) { TQRect r = dev->selection()->selectedExactRect(); 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())); return; } } } m_statusBarSelectionLabel->setText(i18n("No Selection")); } void KisView::updateStatusBarProfileLabel() { if (m_statusBarProfileLabel == 0) { return; } KisImageSP img = currentImg(); if (!img) return; if (img->getProfile() == 0) { m_statusBarProfileLabel->setText(i18n("No profile")); } else { m_statusBarProfileLabel->setText(img->colorSpace()->id().name() + " " + img->getProfile()->productName()); } } KisProfile * KisView::monitorProfile() { if (m_monitorProfile == 0) { resetMonitorProfile(); } return m_monitorProfile; } void KisView::resetMonitorProfile() { m_monitorProfile = KisProfile::getScreenProfile(); if (m_monitorProfile == 0) { KisConfig cfg; TQString monitorProfileName = cfg.monitorProfile(); m_monitorProfile = KisMetaRegistry::instance()->csRegistry()->getProfileByName(monitorProfileName); } } void KisView::setupStatusBar() { KStatusBar *sb = statusBar(); if (sb) { m_statusBarZoomLabel = new TQLabel(sb); addStatusBarItem(m_statusBarZoomLabel,1); updateStatusBarZoomLabel(); m_statusBarSelectionLabel = new KSqueezedTextLabel(sb); addStatusBarItem(m_statusBarSelectionLabel,2); updateStatusBarSelectionLabel(); m_statusBarProfileLabel = new KSqueezedTextLabel(sb); addStatusBarItem(m_statusBarProfileLabel,3); updateStatusBarProfileLabel(); //int height = m_statusBarProfileLabel->height(); m_progress = new KisLabelProgress(this); m_progress->setMaximumWidth(225); m_progress->setMinimumWidth(225); m_progress->setMaximumHeight(fontMetrics().height() ); addStatusBarItem(m_progress, 2, true); m_progress->hide(); } } void KisView::setupActions() { KisConfig cfg; m_selectionManager->setup(actionCollection()); m_filterManager->setup(actionCollection()); m_gridManager->setup(actionCollection()); m_perspectiveGridManager->setup(actionCollection()); m_fullScreen = KStdAction::fullScreen( NULL, NULL, actionCollection(), this ); connect( m_fullScreen, TQT_SIGNAL( toggled( bool )), TQT_TQOBJECT(this), TQT_SLOT( slotUpdateFullScreen( bool ))); m_imgProperties = new KAction(i18n("Image Properties"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotImageProperties()), actionCollection(), "img_properties"); m_imgScan = 0; // How the hell do I get a KAction to the scan plug-in?!? m_imgResizeToLayer = new KAction(i18n("Resize Image to Size of Current Layer"), 0, TQT_TQOBJECT(this), TQT_SLOT(imgResizeToActiveLayer()), actionCollection(), "resizeimgtolayer"); // view actions m_zoomIn = KStdAction::zoomIn(TQT_TQOBJECT(this), TQT_SLOT(slotZoomIn()), actionCollection(), "zoom_in"); m_zoomOut = KStdAction::zoomOut(TQT_TQOBJECT(this), TQT_SLOT(slotZoomOut()), actionCollection(), "zoom_out"); m_actualPixels = new KAction(i18n("Actual Pixels"), "Ctrl+0", TQT_TQOBJECT(this), TQT_SLOT(slotActualPixels()), actionCollection(), "actual_pixels"); m_actualSize = KStdAction::actualSize(TQT_TQOBJECT(this), TQT_SLOT(slotActualSize()), actionCollection(), "actual_size"); m_actualSize->setEnabled(false); m_fitToCanvas = KStdAction::fitToPage(TQT_TQOBJECT(this), TQT_SLOT(slotFitToCanvas()), actionCollection(), "fit_to_canvas"); // layer actions m_layerAdd = new KAction(i18n("&Add..."), "Ctrl+Shift+N", TQT_TQOBJECT(this), TQT_SLOT(layerAdd()), actionCollection(), "insert_layer"); m_actionPartLayer = new KoPartSelectAction( i18n( "&Object Layer" ), "frame_query", TQT_TQOBJECT(this), TQT_SLOT( addPartLayer() ), actionCollection(), "insert_part_layer" ); m_actionAdjustmentLayer = new KAction( i18n( "&Adjustment Layer" ), 0, TQT_TQOBJECT(this), TQT_SLOT( addAdjustmentLayer() ), actionCollection(), "insert_adjustment_layer" ); m_layerRm = new KAction(i18n("&Remove"), 0, TQT_TQOBJECT(this), TQT_SLOT(layerRemove()), actionCollection(), "remove_layer"); m_layerDup = new KAction(i18n("Duplicate"), 0, TQT_TQOBJECT(this), TQT_SLOT(layerDuplicate()), actionCollection(), "duplicate_layer"); m_layerHide = new KToggleAction(i18n("&Hide"), 0, TQT_TQOBJECT(this), TQT_SLOT(layerToggleVisible()), actionCollection(), "hide_layer"); m_layerHide->setCheckedState(KGuiItem(i18n("&Show"))); m_layerHide->setChecked(false); m_layerRaise = new KAction(i18n("Raise"), "raise", "Ctrl+]", TQT_TQOBJECT(this), TQT_SLOT(layerRaise()), actionCollection(), "raiselayer"); m_layerLower = new KAction(i18n("Lower"), "lower", "Ctrl+[", TQT_TQOBJECT(this), TQT_SLOT(layerLower()), actionCollection(), "lowerlayer"); m_layerTop = new KAction(i18n("To Top"), "bring_forward", "Ctrl+Shift+]", TQT_TQOBJECT(this), TQT_SLOT(layerFront()), actionCollection(), "toplayer"); m_layerBottom = new KAction(i18n("To Bottom"), "send_backward", "Ctrl+Shift+[", TQT_TQOBJECT(this), TQT_SLOT(layerBack()), actionCollection(), "bottomlayer"); m_layerProperties = new KAction(i18n("Properties"), 0, TQT_TQOBJECT(this), TQT_SLOT(layerProperties()), actionCollection(), "layer_properties"); (void)new KAction(i18n("I&nsert Image as Layer..."), 0, TQT_TQOBJECT(this), TQT_SLOT(slotInsertImageAsLayer()), actionCollection(), "insert_image_as_layer"); m_layerSaveAs = new KAction(i18n("Save Layer as Image..."), "filesave", TQT_TQOBJECT(this), TQT_SLOT(saveLayerAsImage()), actionCollection(), "save_layer_as_image"); (void)new KAction(i18n("Flip on &X Axis"), "view_left_right", 0, TQT_TQOBJECT(this), TQT_SLOT(mirrorLayerX()), actionCollection(), "mirrorLayerX"); (void)new KAction(i18n("Flip on &Y Axis"), "view_top_bottom", 0, TQT_TQOBJECT(this), TQT_SLOT(mirrorLayerY()), actionCollection(), "mirrorLayerY"); m_createMask = new KAction(i18n("Create Mask"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotCreateMask()), actionCollection(), "create_mask"); m_maskFromSelection = new KAction(i18n("Mask From Selection"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotMaskFromSelection()), actionCollection(), "mask_fromsel"); m_maskToSelection = new KAction(i18n("Mask to Selection"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotMaskToSelection()), actionCollection(), "mask_tosel"); m_applyMask = new KAction(i18n("Apply Mask"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotApplyMask()), actionCollection(), "apply_mask"); m_removeMask = new KAction(i18n("Remove Mask"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotRemoveMask()), actionCollection(), "remove_mask"); m_showMask = new KToggleAction(i18n( "Show Mask" ), 0, TQT_TQOBJECT(this), TQT_SLOT(slotShowMask()), actionCollection(), "show_mask"); m_editMask = new KToggleAction(i18n( "Edit Mask" ), 0, TQT_TQOBJECT(this), TQT_SLOT(slotEditMask()), actionCollection(), "edit_mask"); // image actions m_imgFlatten = new KAction(i18n("&Flatten Image"), "Ctrl+Shift+E", TQT_TQOBJECT(this), TQT_SLOT(flattenImage()), actionCollection(), "flatten_image"); m_imgMergeLayer = new KAction(i18n("&Merge with Layer Below"), "Ctrl+E", TQT_TQOBJECT(this), TQT_SLOT(mergeLayer()), actionCollection(), "merge_layer"); // setting actions KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(preferences()), actionCollection(), "preferences"); m_RulerAction = new KToggleAction( i18n( "Show Rulers" ), "Ctrl+R", TQT_TQOBJECT(this), TQT_SLOT( showRuler() ), actionCollection(), "view_ruler" ); m_RulerAction->setChecked(cfg.showRulers()); m_RulerAction->setCheckedState(i18n("Hide Rulers")); m_RulerAction->setWhatsThis( i18n("The rulers show the horizontal and vertical positions of the mouse on the image " "and can be used to position your mouse at the right place on the canvas.

Uncheck this to disable " "the rulers from being displayed." ) ); //m_guideAction = new KToggleAction( i18n( "Guide Lines" ), 0, TQT_TQOBJECT(this), TQT_SLOT( viewGuideLines() ), actionCollection(), "view_guidelines" ); // Add new palette new KAction(i18n("Add New Palette..."), 0, TQT_TQOBJECT(this), TQT_SLOT(slotAddPalette()), actionCollection(), "add_palette"); new KAction(i18n("Edit Palette..."), 0, TQT_TQOBJECT(this), TQT_SLOT(slotEditPalette()), actionCollection(), "edit_palette"); // XXX: This triggers a repaint of the image, but way too early //showRuler(); } void KisView::resizeEvent(TQResizeEvent *) { if (!m_paintViewEnabled) { startInitialZoomTimerIfReady(); } KisImageSP img = currentImg(); TQ_INT32 scrollBarExtent = style().pixelMetric(TQStyle::PM_ScrollBarExtent); TQ_INT32 drawH; TQ_INT32 drawW; TQ_INT32 docW; TQ_INT32 docH; // if (img) { // KisGuideMgr *mgr = img->guides(); // mgr->resize(size()); // } docW = static_cast(ceil(docWidth() * zoom())); docH = static_cast(ceil(docHeight() * zoom())); m_rulerThickness = m_RulerAction->isChecked() ? RULER_THICKNESS : 0; drawH = height() - m_rulerThickness; drawW = width() - m_rulerThickness; if (drawH < docH) { // Will need vert scrollbar drawW -= scrollBarExtent; if (drawW < docW) // Will need horiz scrollbar drawH -= scrollBarExtent; } else if (drawW < docW) { // Will need horiz scrollbar drawH -= scrollBarExtent; if (drawH < docH) // Will need vert scrollbar drawW -= scrollBarExtent; } m_vScroll->setEnabled(docH > drawH); m_hScroll->setEnabled(docW > drawW); if (docH <= drawH && docW <= drawW) { // we need no scrollbars m_vScroll->hide(); m_hScroll->hide(); m_vScroll->setValue(0); m_hScroll->setValue(0); m_vScrollBarExtent = 0; m_hScrollBarExtent = 0; } else if (docH <= drawH) { // we need a horizontal scrollbar only m_vScroll->hide(); m_vScroll->setValue(0); m_hScroll->setRange(0, docW - drawW); m_hScroll->setGeometry(m_rulerThickness, height() - scrollBarExtent, width() - m_rulerThickness, scrollBarExtent); m_hScroll->show(); m_hScrollBarExtent = scrollBarExtent; m_hScrollBarExtent = scrollBarExtent; } else if(docW <= drawW) { // we need a vertical scrollbar only m_hScroll->hide(); m_hScroll->setValue(0); m_vScroll->setRange(0, docH - drawH); m_vScroll->setGeometry(width() - scrollBarExtent, m_rulerThickness, scrollBarExtent, height() - m_rulerThickness); m_vScroll->show(); m_vScrollBarExtent = scrollBarExtent; } else { // we need both scrollbars m_vScroll->setRange(0, docH - drawH); m_vScroll->setGeometry(width() - scrollBarExtent, m_rulerThickness, scrollBarExtent, height() -2* m_rulerThickness); m_hScroll->setRange(0, docW - drawW); m_hScroll->setGeometry(m_rulerThickness, height() - scrollBarExtent, width() - 2*m_rulerThickness, scrollBarExtent); m_vScroll->show(); m_hScroll->show(); m_vScrollBarExtent = scrollBarExtent; m_hScrollBarExtent = scrollBarExtent; } TQ_INT32 oldCanvasXOffset = m_canvasXOffset; TQ_INT32 oldCanvasYOffset = m_canvasYOffset; if (docW < drawW) { m_canvasXOffset = (drawW - docW) / 2; } else { m_canvasXOffset = 0; } if (docH < drawH) { m_canvasYOffset = (drawH - docH) / 2; } else { m_canvasYOffset = 0; } //Check if rulers are visible if( m_RulerAction->isChecked() ) m_canvas->setGeometry(m_rulerThickness, m_rulerThickness, drawW, drawH); else m_canvas->setGeometry(0, 0, drawW, drawH); m_canvas->show(); if (!m_canvas->isOpenGLCanvas()) { if (m_canvasPixmap.size() != TQSize(drawW, drawH)) { TQ_INT32 oldCanvasWidth = m_canvasPixmap.width(); TQ_INT32 oldCanvasHeight = m_canvasPixmap.height(); TQ_INT32 newCanvasWidth = drawW; TQ_INT32 newCanvasHeight = drawH; TQRegion exposedRegion = TQRect(0, 0, newCanvasWidth, newCanvasHeight); // Increase size first so that we can copy the old image area to the new one. m_canvasPixmap.resize(TQMAX(oldCanvasWidth, newCanvasWidth), TQMAX(oldCanvasHeight, newCanvasHeight)); if (!m_canvasPixmap.isNull()) { if (oldCanvasXOffset != m_canvasXOffset || oldCanvasYOffset != m_canvasYOffset) { TQ_INT32 srcX; TQ_INT32 srcY; TQ_INT32 srcWidth; TQ_INT32 srcHeight; TQ_INT32 dstX; TQ_INT32 dstY; if (oldCanvasXOffset <= m_canvasXOffset) { // Move to the right srcX = 0; dstX = m_canvasXOffset - oldCanvasXOffset; srcWidth = oldCanvasWidth; } else { // Move to the left srcX = oldCanvasXOffset - m_canvasXOffset; dstX = 0; srcWidth = newCanvasWidth; } if (oldCanvasYOffset <= m_canvasYOffset) { // Move down srcY = 0; dstY = m_canvasYOffset - oldCanvasYOffset; srcHeight = oldCanvasHeight; } else { // Move up srcY = oldCanvasYOffset - m_canvasYOffset; dstY = 0; srcHeight = newCanvasHeight; } bitBlt(&m_canvasPixmap, dstX, dstY, &m_canvasPixmap, srcX, srcY, srcWidth, srcHeight); exposedRegion -= TQRegion(TQRect(dstX, dstY, srcWidth, srcHeight)); } else { exposedRegion -= TQRegion(TQRect(0, 0, oldCanvasWidth, oldCanvasHeight)); } } m_canvasPixmap.resize(newCanvasWidth, newCanvasHeight); if (!m_canvasPixmap.isNull() && !exposedRegion.isEmpty()) { TQMemArray rects = exposedRegion.rects(); for (unsigned int i = 0; i < rects.count(); i++) { TQRect r = rects[i]; updateTQPaintDeviceCanvas(viewToWindow(r)); } } } } int fontheight = TQFontMetrics(TDEGlobalSettings::generalFont()).height() * 3; m_vScroll->setPageStep(drawH); m_vScroll->setLineStep(fontheight); m_hScroll->setPageStep(drawW); m_hScroll->setLineStep(fontheight); m_hRuler->setGeometry(m_rulerThickness + m_canvasXOffset, 0, TQMIN(docW, drawW), m_rulerThickness); m_vRuler->setGeometry(0, m_rulerThickness + m_canvasYOffset, m_rulerThickness, TQMIN(docH, drawH)); if (m_vScroll->isVisible()) m_vRuler->updateVisibleArea(0, m_vScroll->value()); else m_vRuler->updateVisibleArea(0, 0); if (m_hScroll->isVisible()) m_hRuler->updateVisibleArea(m_hScroll->value(), 0); else m_hRuler->updateVisibleArea(0, 0); if( m_RulerAction->isChecked() ) { m_hRuler->show(); m_vRuler->show(); } else { m_hRuler->hide(); m_vRuler->hide(); } emit viewTransformationsChanged(); } void KisView::styleChange(TQStyle& oldStyle) { Q_UNUSED(oldStyle); m_canvas->updateGeometry(); refreshKisCanvas(); } void KisView::paletteChange(const TQPalette& oldPalette) { Q_UNUSED(oldPalette); refreshKisCanvas(); } void KisView::showEvent(TQShowEvent *) { if (!m_showEventReceived) { m_showEventReceived = true; startInitialZoomTimerIfReady(); } } void KisView::updateReadWrite(bool readwrite) { layerUpdateGUI(readwrite); } TQ_INT32 KisView::horzValue() const { return m_hScroll->value() - m_canvasXOffset; } TQ_INT32 KisView::vertValue() const { return m_vScroll->value() - m_canvasYOffset; } void KisView::updateTQPaintDeviceCanvas(const TQRect& imageRect) { TQRect vr = windowToView(imageRect); vr &= TQRect(0, 0, m_canvas->width(), m_canvas->height()); if (!vr.isEmpty()) { TQPainter gc; if (gc.begin(&m_canvasPixmap)) { KisImageSP img = currentImg(); if (img && m_paintViewEnabled) { TQRect wr = viewToWindow(vr); if (wr.left() < 0 || wr.right() >= img->width() || wr.top() < 0 || wr.bottom() >= img->height()) { // Erase areas outside document TQRegion rg(vr); rg -= TQRegion(windowToView(TQRect(0, 0, img->width(), img->height()))); TQMemArray rects = rg.rects(); for (unsigned int i = 0; i < rects.count(); i++) { TQRect er = rects[i]; gc.fillRect(er, colorGroup().mid()); } wr &= TQRect(0, 0, img->width(), img->height()); } if (!wr.isEmpty()) { KisImage::PaintFlags paintFlags = (KisImage::PaintFlags)KisImage::PAINT_BACKGROUND; if (m_actLayerVis) { paintFlags = (KisImage::PaintFlags)(paintFlags|KisImage::PAINT_MASKINACTIVELAYERS); } if (m_selectionManager->displaySelection()) { paintFlags = (KisImage::PaintFlags)(paintFlags|KisImage::PAINT_SELECTION); } if (zoom() > 1.0 - EPSILON) { gc.setWorldXForm(true); gc.translate(-horzValue(), -vertValue()); gc.scale(zoomFactor(), zoomFactor()); m_image->renderToPainter(wr.left(), wr.top(), wr.right(), wr.bottom(), gc, monitorProfile(), paintFlags, HDRExposure()); } else { TQRect canvasRect = windowToView(wr); TQRect scaledImageRect = canvasRect; scaledImageRect.moveBy(horzValue(), vertValue()); TQSize scaledImageSize(static_cast(ceil(docWidth() * zoom())), static_cast(ceil(docHeight() * zoom()))); TQImage image = m_image->convertToTQImage(scaledImageRect, scaledImageSize, monitorProfile(), paintFlags, HDRExposure()); gc.drawImage(canvasRect.topLeft(), image, image.rect()); // Set up for the grid drawer. gc.setWorldXForm(true); gc.translate(-horzValue(), -vertValue()); gc.scale(zoomFactor(), zoomFactor()); } m_gridManager->drawGrid( wr, &gc ); m_perspectiveGridManager->drawGrid( wr, &gc ); } // paintGuides(); } else { gc.fillRect(vr, colorGroup().mid()); } } } } void KisView::paintTQPaintDeviceView(const TQRegion& canvasRegion) { Q_ASSERT(m_canvas->TQPaintDeviceWidget() != 0); if (m_canvas->TQPaintDeviceWidget() != 0 && !m_canvasPixmap.isNull()) { TQMemArray rects = canvasRegion.rects(); for (unsigned int i = 0; i < rects.count(); i++) { TQRect r = rects[i]; bitBlt(m_canvas->TQPaintDeviceWidget(), r.x(), r.y(), &m_canvasPixmap, r.x(), r.y(), r.width(), r.height()); } paintToolOverlay(canvasRegion); } } void KisView::updateOpenGLCanvas(const TQRect& imageRect) { #ifdef HAVE_GL KisImageSP img = currentImg(); if (img && m_paintViewEnabled) { Q_ASSERT(m_OpenGLImageContext != 0); if (m_OpenGLImageContext != 0) { m_OpenGLImageContext->update(imageRect); } } #else Q_UNUSED(imageRect); #endif } void KisView::paintOpenGLView(const TQRect& canvasRect) { #ifdef HAVE_GL if (!m_canvas->isUpdatesEnabled()) { return; } m_canvas->OpenGLWidget()->makeCurrent(); glDrawBuffer(GL_BACK); TQColor widgetBackgroundColor = colorGroup().mid(); glClearColor(widgetBackgroundColor.red() / 255.0, widgetBackgroundColor.green() / 255.0, widgetBackgroundColor.blue() / 255.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); KisImageSP img = currentImg(); if (img && m_paintViewEnabled) { TQRect vr = canvasRect; vr &= TQRect(0, 0, m_canvas->width(), m_canvas->height()); if (!vr.isNull()) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glViewport(0, 0, m_canvas->width(), m_canvas->height()); glOrtho(0, m_canvas->width(), m_canvas->height(), 0, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glBindTexture(GL_TEXTURE_2D, m_OpenGLImageContext->backgroundTexture()); glTranslatef(m_canvasXOffset, m_canvasYOffset, 0.0); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex2f(0.0, 0.0); glTexCoord2f((img->width() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_WIDTH, 0.0); glVertex2f(img->width() * zoom(), 0.0); glTexCoord2f((img->width() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_WIDTH, (img->height() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_HEIGHT); glVertex2f(img->width() * zoom(), img->height() * zoom()); glTexCoord2f(0.0, (img->height() * zoom()) / KisOpenGLImageContext::BACKGROUND_TEXTURE_HEIGHT); glVertex2f(0.0, img->height() * zoom()); glEnd(); glTranslatef(-m_canvasXOffset, -m_canvasYOffset, 0.0); glTranslatef(-horzValue(), -vertValue(), 0.0); glScalef(zoomFactor(), zoomFactor(), 1.0); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); TQRect wr = viewToWindow(TQRect(0, 0, m_canvas->width(), m_canvas->height())); wr &= TQRect(0, 0, img->width(), img->height()); m_OpenGLImageContext->setHDRExposure(HDRExposure()); m_canvas->OpenGLWidget()->makeCurrent(); for (int x = (wr.left() / m_OpenGLImageContext->imageTextureTileWidth()) * m_OpenGLImageContext->imageTextureTileWidth(); x <= wr.right(); x += m_OpenGLImageContext->imageTextureTileWidth()) { for (int y = (wr.top() / m_OpenGLImageContext->imageTextureTileHeight()) * m_OpenGLImageContext->imageTextureTileHeight(); y <= wr.bottom(); y += m_OpenGLImageContext->imageTextureTileHeight()) { glBindTexture(GL_TEXTURE_2D, m_OpenGLImageContext->imageTextureTile(x, y)); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex2f(x, y); glTexCoord2f(1.0, 0.0); glVertex2f(x + m_OpenGLImageContext->imageTextureTileWidth(), y); glTexCoord2f(1.0, 1.0); glVertex2f(x + m_OpenGLImageContext->imageTextureTileWidth(), y + m_OpenGLImageContext->imageTextureTileHeight()); glTexCoord2f(0.0, 1.0); glVertex2f(x, y + m_OpenGLImageContext->imageTextureTileHeight()); glEnd(); } } glDisable(GL_TEXTURE_2D); glDisable(GL_BLEND); m_gridManager->drawGrid(wr, 0, true); m_perspectiveGridManager->drawGrid( wr, 0, true ); // Unbind the texture otherwise the ATI driver crashes when the canvas context is // made current after the textures are deleted following an image resize. glBindTexture(GL_TEXTURE_2D, 0); //paintGuides(); } } m_canvas->OpenGLWidget()->swapBuffers(); paintToolOverlay(TQRegion(canvasRect)); #else Q_UNUSED(canvasRect); #endif } void KisView::setInputDevice(KisInputDevice inputDevice) { if (inputDevice != m_inputDevice) { m_inputDevice = inputDevice; m_toolManager->setToolForInputDevice(m_inputDevice, inputDevice); if (m_toolManager->currentTool() == 0) { m_toolManager->setCurrentTool(m_toolManager->findTool("tool_brush", m_inputDevice)); } else { m_toolManager->setCurrentTool(m_toolManager->currentTool()); } m_toolManager->activateCurrentTool(); emit sigInputDeviceChanged(inputDevice); } } KisInputDevice KisView::currentInputDevice() const { return m_inputDevice; } KisCanvas *KisView::kiscanvas() const { return m_canvas; } void KisView::updateCanvas() { if (m_image) { updateCanvas(m_image->bounds()); } } void KisView::updateCanvas(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h) { updateCanvas(TQRect(x, y, w, h)); } void KisView::updateCanvas(const TQRect& imageRect) { if (m_canvas->isOpenGLCanvas()) { updateOpenGLCanvas(imageRect); paintOpenGLView(windowToView(imageRect)); } else { updateTQPaintDeviceCanvas(imageRect); //m_canvas->update(windowToView(imageRect)); m_canvas->repaint(windowToView(imageRect)); } } void KisView::refreshKisCanvas() { TQRect imageRect = viewToWindow(TQRect(0, 0, m_canvas->width(), m_canvas->height())); if (m_image) { imageRect |= m_image->bounds(); } updateCanvas(imageRect); // Enable this if updateCanvas does an m_canvas->update() //m_canvas->repaint(); } void KisView::selectionDisplayToggled(bool displaySelection) { #ifdef HAVE_GL if (m_canvas->isOpenGLCanvas()) { if (m_OpenGLImageContext) { m_OpenGLImageContext->setSelectionDisplayEnabled(displaySelection); } } #else Q_UNUSED(displaySelection); #endif updateCanvas(); } void KisView::layerUpdateGUI(bool enable) { KisImageSP img = currentImg(); KisLayerSP layer; TQ_INT32 nlayers = 0; TQ_INT32 nvisible = 0; if (img) { layer = img->activeLayer(); nlayers = img->nlayers(); nvisible = nlayers - img->nHiddenLayers(); } KisPaintLayer * pl = dynamic_cast(layer.data()); if (pl && ( m_currentColorChooserDisplay != KisID("BLA") || pl->paintDevice()->colorSpace()->id() != m_currentColorChooserDisplay)) { if (pl->paintDevice()->colorSpace()->id() == KisID("WET")) { m_paletteManager->hideWidget( "hsvwidget" ); m_paletteManager->hideWidget( "rgbwidget" ); m_paletteManager->hideWidget( "graywidget" ); m_paletteManager->hideWidget( "palettewidget" ); m_paletteManager->showWidget( "watercolor docker" ); } else { m_paletteManager->hideWidget( "watercolor docker" ); m_paletteManager->showWidget( "palettewidget" ); m_paletteManager->showWidget( "graywidget" ); m_paletteManager->showWidget( "rgbwidget" ); m_paletteManager->showWidget( "hsvwidget" ); } m_currentColorChooserDisplay = pl->paintDevice()->colorSpace()->id(); } enable = enable && img && layer && layer->visible() && !layer->locked(); m_layerDup->setEnabled(enable); m_layerRm->setEnabled(enable); m_layerHide->setEnabled(img && layer); m_layerProperties->setEnabled(enable); m_layerSaveAs->setEnabled(enable); m_layerRaise->setEnabled(enable && layer->prevSibling()); m_layerLower->setEnabled(enable && layer->nextSibling()); m_layerTop->setEnabled(enable && nlayers > 1 && layer != img->rootLayer()->firstChild()); m_layerBottom->setEnabled(enable && nlayers > 1 && layer != img->rootLayer()->lastChild()); // XXX these should be named layer instead of img m_imgFlatten->setEnabled(nlayers > 1); m_imgMergeLayer->setEnabled(nlayers > 1 && layer && layer->nextSibling()); m_selectionManager->updateGUI(); m_filterManager->updateGUI(); m_toolManager->updateGUI(); m_gridManager->updateGUI(); m_perspectiveGridManager->updateGUI(); KisPartLayer * partLayer = dynamic_cast(layer.data()); if (partLayer) { setCanvasCursor( KisCursor::arrowCursor() ); } if (img && img->activeDevice()) emit currentColorSpaceChanged(img->activeDevice()->colorSpace()); imgUpdateGUI(); } void KisView::imgUpdateGUI() { KisImageSP img = currentImg(); m_imgResizeToLayer->setEnabled(img && img->activeLayer()); updateStatusBarProfileLabel(); } static const double zoomLevels[] = { 1.0 / 500, 1.0 / 333.333333, 1.0 / 250, 1.0 / 200, 1.0 / 150, 1.0 / 100, 1.0 / 66.666667, 1.0 / 50, 1.0 / 33.333333, 1.0 / 25, 1.0 / 20, 1.0 / 16, 1.0 / 12, 1.0 / 8, 1.0 / 6, 1.0 / 4, 1.0 / 3, 1.0 / 2, 1.0 / 1.5, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16 }; #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) #define NUM_ZOOM_LEVELS ARRAY_SIZE(zoomLevels) #define FIRST_ZOOM_LEVEL_INDEX 0 #define LAST_ZOOM_LEVEL_INDEX (NUM_ZOOM_LEVELS - 1) #define KISVIEW_MIN_ZOOM (zoomLevels[FIRST_ZOOM_LEVEL_INDEX]) #define KISVIEW_MAX_ZOOM (zoomLevels[LAST_ZOOM_LEVEL_INDEX]) double KisView::nextZoomInLevel() const { uint zoomLevelIndex = FIRST_ZOOM_LEVEL_INDEX; while (zoom() >= zoomLevels[zoomLevelIndex] && zoomLevelIndex < LAST_ZOOM_LEVEL_INDEX) { zoomLevelIndex++; } return zoomLevels[zoomLevelIndex]; } double KisView::nextZoomOutLevel(double zoomLevel) const { int zoomLevelIndex = LAST_ZOOM_LEVEL_INDEX; while (zoomLevel <= zoomLevels[zoomLevelIndex] && zoomLevelIndex > FIRST_ZOOM_LEVEL_INDEX) { zoomLevelIndex--; } return zoomLevels[zoomLevelIndex]; } double KisView::nextZoomOutLevel() const { return nextZoomOutLevel(zoom()); } void KisView::zoomAroundPoint(double x, double y, double zf) { // Disable updates while we change the scrollbar settings. m_canvas->setUpdatesEnabled(false); m_hScroll->setUpdatesEnabled(false); m_vScroll->setUpdatesEnabled(false); if (x < 0 || y < 0) { // Zoom about the centre of the current display KisImageSP img = currentImg(); if (img) { if (m_hScroll->isVisible()) { KisPoint c = viewToWindow(KisPoint(m_canvas->width() / 2.0, m_canvas->height() / 2.0)); x = c.x(); } else { x = img->width() / 2.0; } if (m_vScroll->isVisible()) { KisPoint c = viewToWindow(KisPoint(m_canvas->width() / 2.0, m_canvas->height() / 2.0)); y = c.y(); } else { y = img->height() / 2.0; } } else { x = 0; y = 0; } } setZoom(zf); Q_ASSERT(m_zoomIn); Q_ASSERT(m_zoomOut); updateStatusBarZoomLabel (); m_zoomIn->setEnabled(zf < KISVIEW_MAX_ZOOM); m_zoomOut->setEnabled(zf > KISVIEW_MIN_ZOOM); resizeEvent(0); m_hRuler->setZoom(zf); m_vRuler->setZoom(zf); if (m_hScroll->isVisible()) { double vcx = m_canvas->width() / 2.0; TQ_INT32 scrollX = tqRound(x * zoom() - vcx); m_hScroll->setValue(scrollX); } if (m_vScroll->isVisible()) { double vcy = m_canvas->height() / 2.0; TQ_INT32 scrollY = tqRound(y * zoom() - vcy); m_vScroll->setValue(scrollY); } // Now update everything. m_canvas->setUpdatesEnabled(true); m_hScroll->setUpdatesEnabled(true); m_vScroll->setUpdatesEnabled(true); m_hScroll->update(); m_vScroll->update(); if (m_canvas->isOpenGLCanvas()) { paintOpenGLView(TQRect(0, 0, m_canvas->width(), m_canvas->height())); } else { refreshKisCanvas(); } emit viewTransformationsChanged(); } void KisView::zoomTo(const KisRect& r) { if (!r.isNull()) { double wZoom = fabs(m_canvas->width() / r.width()); double hZoom = fabs(m_canvas->height() / r.height()); double zf = kMin(wZoom, hZoom); if (zf < KISVIEW_MIN_ZOOM) { zf = KISVIEW_MIN_ZOOM; } else if (zf > KISVIEW_MAX_ZOOM) { zf = KISVIEW_MAX_ZOOM; } zoomAroundPoint(r.center().x(), r.center().y(), zf); } } void KisView::zoomTo(const TQRect& r) { zoomTo(KisRect(r)); } void KisView::zoomTo(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h) { zoomTo(KisRect(x, y, w, h)); } void KisView::zoomIn(TQ_INT32 x, TQ_INT32 y) { zoomAroundPoint(x, y, nextZoomInLevel()); } void KisView::zoomOut(TQ_INT32 x, TQ_INT32 y) { zoomAroundPoint(x, y, nextZoomOutLevel()); } void KisView::zoomIn() { slotZoomIn(); } void KisView::zoomOut() { slotZoomOut(); } void KisView::slotZoomIn() { zoomIn(-1, -1); } void KisView::slotZoomOut() { zoomOut(-1, -1); } void KisView::slotActualPixels() { zoomAroundPoint(-1, -1, 1.0); } void KisView::slotActualSize() { //XXX later this should be update to take screen res and image res into consideration zoomAroundPoint(-1, -1, 1.0); } double KisView::fitToCanvasZoomLevel() const { int fullCanvasWidth = width(); if (m_vRuler->isVisible()) { fullCanvasWidth -= m_vRuler->width(); } int fullCanvasHeight = height(); if (m_hRuler->isVisible()) { fullCanvasHeight -= m_hRuler->height(); } KisImageSP img = currentImg(); if (img) { double xZoomLevel = static_cast(fullCanvasWidth) / img->width(); double yZoomLevel = static_cast(fullCanvasHeight) / img->height(); return TQMIN(xZoomLevel, yZoomLevel); } else { return 1; } } void KisView::slotFitToCanvas() { zoomAroundPoint(-1, -1, fitToCanvasZoomLevel()); } void KisView::setInitialZoomLevel() { double zoomLevel = fitToCanvasZoomLevel(); if (zoomLevel > 1) { zoomLevel = 1; } else { zoomLevel = nextZoomOutLevel(zoomLevel); } zoomAroundPoint(-1, -1, zoomLevel); } void KisView::imgResizeToActiveLayer() { KisImageSP img = currentImg(); KisLayerSP layer; if (img && (layer = img->activeLayer())) { if (m_adapter && m_adapter->undo()) { m_adapter->beginMacro(i18n("Resize Image to Size of Current Layer")); } img->lock(); TQRect r = layer->exactBounds(); img->resize(r.width(), r.height(), r.x(), r.y(), true); img->unlock(); if (m_adapter && m_adapter->undo()) { m_adapter->endMacro(); } } } void KisView::slotImageProperties() { KisImageSP img = currentImg(); if (!img) return; KisDlgImageProperties dlg(img, this); if (dlg.exec() == TQDialog::Accepted) { if (dlg.imageWidth() != img->width() || dlg.imageHeight() != img->height()) { resizeCurrentImage(dlg.imageWidth(), dlg.imageHeight()); } TQ_INT32 opacity = dlg.opacity(); opacity = opacity * 255 / 100; img->setName(dlg.imageName()); img->setColorSpace(dlg.colorSpace()); img->setResolution(dlg.resolution(), dlg.resolution()); img->setDescription(dlg.description()); img->setProfile(dlg.profile()); } } void KisView::slotInsertImageAsLayer() { if (importImage() > 0) m_doc->setModified(true); } void KisView::slotAddPalette() { KDialogBase* base = new KDialogBase(this, 0, true, i18n("Add Palette"), KDialogBase::Ok | KDialogBase::Cancel); KisCustomPalette* p = new KisCustomPalette(base, "add palette", i18n("Add Palette"), this); base->setMainWidget(p); base->show(); } void KisView::slotEditPalette() { KisPaletteChooser chooser(this); KisResourceServerBase* srv = KisResourceServerRegistry::instance()->get("PaletteServer"); if (!srv) { return; } TQValueList resources = srv->resources(); TQValueList palettes; for(uint i = 0; i < resources.count(); i++) { KisPalette* palette = dynamic_cast(*resources.at(i)); chooser.paletteList->insertItem(palette->name()); palettes.append(palette); } if (chooser.exec() != TQDialog::Accepted ) { return; } int index = chooser.paletteList->currentItem(); if (index < 0) { KMessageBox::error(this, i18n("No palette selected."), i18n("Palette")); return; } KDialogBase* base = new KDialogBase(this, 0, true, i18n("Edit Palette") , KDialogBase::Ok); KisCustomPalette* cp = new KisCustomPalette(base, "edit palette", i18n("Edit Palette"), this); cp->setEditMode(true); cp->setPalette(*palettes.at(index)); base->setMainWidget(cp); base->show(); } void KisView::saveLayerAsImage() { TQStringList listMimeFilter = KoFilterManager::mimeFilter("application/x-chalk", KoFilterManager::Export); TQString mimelist = listMimeFilter.join(" "); KFileDialog fd (TQString(), mimelist, this, "Export Layer", true); fd.setCaption(i18n("Export Layer")); fd.setMimeFilter(listMimeFilter); fd.setOperationMode(KFileDialog::Saving); if (!fd.exec()) return; KURL url = fd.selectedURL(); TQString mimefilter = fd.currentMimeFilter(); if (url.isEmpty()) return; KisImageSP img = currentImg(); if (!img) return; KisLayerSP l = img->activeLayer(); if (!l) return; TQRect r = l->exactBounds(); KisDoc d; d.prepareForImport(); KisImageSP dst = new KisImage(d.undoAdapter(), r.width(), r.height(), img->colorSpace(), l->name()); d.setCurrentImage( dst ); dst->addLayer(l->clone(),dst->rootLayer(),0); d.setOutputMimeType(mimefilter.latin1()); d.exp0rt(url); } TQ_INT32 KisView::importImage(const KURL& urlArg) { KisImageSP currentImage = currentImg(); if (!currentImage) { return 0; } KURL::List urls; TQ_INT32 rc = 0; if (urlArg.isEmpty()) { TQString mimelist = KoFilterManager::mimeFilter("application/x-chalk", KoFilterManager::Import).join(" "); urls = KFileDialog::getOpenURLs(TQString(), mimelist, 0, i18n("Import Image")); } else { urls.push_back(urlArg); } if (urls.empty()) return 0; for (KURL::List::iterator it = urls.begin(); it != urls.end(); ++it) { new KisImportCatcher( *it, currentImage ); } updateCanvas(); return rc; } void KisView::rotateLayer180() { rotateLayer( M_PI ); } void KisView::rotateLayerLeft90() { rotateLayer( M_PI/2 - 2*M_PI ); } void KisView::rotateLayerRight90() { rotateLayer( M_PI/2 ); } void KisView::mirrorLayerX() { if (!currentImg()) return; KisPaintDeviceSP dev = currentImg()->activeDevice(); if (!dev) return; KisTransaction * t = 0; if (undoAdapter() && undoAdapter()->undo()) { t = new KisTransaction(i18n("Mirror Layer X"), dev); TQ_CHECK_PTR(t); } dev->mirrorX(); if (t) undoAdapter()->addCommand(t); m_doc->setModified(true); layersUpdated(); updateCanvas(); } void KisView::mirrorLayerY() { if (!currentImg()) return; KisPaintDeviceSP dev = currentImg()->activeDevice(); if (!dev) return; KisTransaction * t = 0; if (undoAdapter() && undoAdapter()->undo()) { t = new KisTransaction(i18n("Mirror Layer Y"), dev); TQ_CHECK_PTR(t); } dev->mirrorY(); if (t) undoAdapter()->addCommand(t); m_doc->setModified(true); layersUpdated(); updateCanvas(); } void KisView::scaleLayer(double sx, double sy, KisFilterStrategy *filterStrategy) { if (!currentImg()) return; KisPaintDeviceSP dev = currentImg()->activeDevice(); if (!dev) return; KisSelectedTransaction * t = 0; if (undoAdapter() && undoAdapter()->undo()) { t = new KisSelectedTransaction(i18n("Scale Layer"), dev); TQ_CHECK_PTR(t); } KisTransformWorker worker(dev, sx, sy, 0, 0, 0.0, 0, 0, m_progress, filterStrategy); worker.run(); if (t) undoAdapter()->addCommand(t); currentImg()->rootLayer()->setDirty(false); m_doc->setModified(true); layersUpdated(); updateCanvas(); } void KisView::rotateLayer(double radians) { if (!currentImg()) return; KisPaintDeviceSP dev = currentImg()->activeDevice(); if (!dev) return; KisSelectedTransaction * t = 0; if (undoAdapter() && undoAdapter()->undo()) { t = new KisSelectedTransaction(i18n("Rotate Layer"), dev); TQ_CHECK_PTR(t); } KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->get(KisID("Triangle")); TQRect r; if(dev->hasSelection()) r = dev->selection()->selectedExactRect(); else r = dev->exactBounds(); double cx = r.x()+r.width()/2.0; double cy = r.y()+r.height()/2.0; TQ_INT32 tx = TQ_INT32(cx*cos(radians) - cy*sin(radians) - cx + 0.5); TQ_INT32 ty = TQ_INT32(cy*cos(radians) + cx*sin(radians) - cy + 0.5); KisTransformWorker tw(dev, 1.0, 1.0, 0, 0, radians, -tx, -ty, m_progress, filter); tw.run(); if (t) undoAdapter()->addCommand(t); m_doc->setModified(true); layersUpdated(); updateCanvas(); } void KisView::shearLayer(double angleX, double angleY) { if (!currentImg()) return; KisLayerSP layer = currentImg()->activeLayer(); if (!layer) return; KisUndoAdapter * undo = 0; if ((undo = currentImg()->undoAdapter())) { undo->beginMacro(i18n("Shear layer")); } KisShearVisitor v(angleX, angleY, m_progress); v.setUndoAdapter(undo); layer->accept(v); if (undo) undo->endMacro(); m_doc->setModified(true); layersUpdated(); updateCanvas(); } void KisView::flattenImage() { KisImageSP img = currentImg(); if (img) { bool doIt = true; if (img->nHiddenLayers() > 0) { int answer = KMessageBox::warningYesNo(this, i18n("The image contains hidden layers that will be lost."), i18n("Flatten Image"), i18n("&Flatten Image"), KStdGuiItem::cancel()); if (answer != KMessageBox::Yes) { doIt = false; } } if (doIt) { img->flatten(); } } } void KisView::mergeLayer() { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); if (!layer) return; img->mergeLayer(layer); } void KisView::preferences() { #ifdef HAVE_GL bool canvasWasOpenGL = m_canvas->isOpenGLCanvas(); #endif if (PreferencesDialog::editPreferences()) { KisConfig cfg; m_paletteManager->slotResetFont(); resetMonitorProfile(); #ifdef HAVE_GL if (cfg.useOpenGL() != canvasWasOpenGL) { disconnectCurrentImg(); //XXX: Need to notify other views that this global setting has changed. if (cfg.useOpenGL()) { m_OpenGLImageContext = KisOpenGLImageContext::getImageContext(m_image, monitorProfile()); m_canvas->createOpenGLCanvas(m_OpenGLImageContext->sharedContextWidget()); } else { m_OpenGLImageContext = 0; m_canvas->createTQPaintDeviceCanvas(); } connectCurrentImg(); resizeEvent(0); } if (cfg.useOpenGL()) { m_OpenGLImageContext->setMonitorProfile(monitorProfile()); } #endif refreshKisCanvas(); if (m_toolManager->currentTool()) { setCanvasCursor(m_toolManager->currentTool()->cursor()); } #if defined(EXTENDED_X11_TABLET_SUPPORT) m_canvas->selectTabletDeviceEvents(); #endif } } void KisView::layerCompositeOp(const KisCompositeOp& compositeOp) { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); if (!layer) return; if (img->undo()) { KNamedCommand *cmd = layer->setCompositeOpCommand(compositeOp); cmd->execute(); undoAdapter()->addCommand(cmd); } } // range: 0 - 100 void KisView::layerOpacity(int opacity, bool dontundo) { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); if (!layer) return; opacity = int(float(opacity * 255) / 100 + 0.5); if (opacity > 255) opacity = 255; if (opacity == layer->opacity()) return; if (dontundo) layer->setOpacity( opacity ); else { if (img->undo()) { KNamedCommand *cmd = layer->setOpacityCommand(opacity); cmd->execute(); undoAdapter()->addCommand(cmd); } } } void KisView::layerOpacityFinishedChanging( int previous, int opacity ) { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); if (!layer) return; opacity = int(float(opacity * 255) / 100 + 0.5); if (opacity > 255) opacity = 255; previous = int(float(previous * 255) / 100 + 0.5); if (previous > 255) previous = 255; if (previous == opacity) return; if (img->undo()) { KNamedCommand *cmd = layer->setOpacityCommand(previous, opacity); m_adapter->addCommand(cmd); } } void KisView::showRuler() { if( m_RulerAction->isChecked() ) { m_hRuler->show(); m_vRuler->show(); } else { m_hRuler->hide(); m_vRuler->hide(); } resizeEvent(0); refreshKisCanvas(); } void KisView::slotUpdateFullScreen(bool toggle) { if (KoView::shell()) { uint newState = KoView::shell()->windowState(); if (toggle) { newState |= TQt::WindowFullScreen; } else { newState &= ~TQt::WindowFullScreen; } KoView::shell()->setWindowState(newState); } } TQ_INT32 KisView::docWidth() const { return currentImg() ? currentImg()->width() : 0; } TQ_INT32 KisView::docHeight() const { return currentImg() ? currentImg()->height() : 0; } void KisView::scrollTo(TQ_INT32 x, TQ_INT32 y) { if (m_hScroll->isVisible()) { m_hScroll->setValue(x); } if (m_vScroll->isVisible()) { m_vScroll->setValue(y); } } void KisView::brushActivated(KisResource *brush) { m_brush = dynamic_cast(brush); if (m_brush ) { emit brushChanged(m_brush); notifyObservers(); } } void KisView::patternActivated(KisResource *pattern) { m_pattern = dynamic_cast(pattern); if (m_pattern) { emit patternChanged(m_pattern); notifyObservers(); } } void KisView::gradientActivated(KisResource *gradient) { m_gradient = dynamic_cast(gradient); if (m_gradient) { emit gradientChanged(m_gradient); notifyObservers(); } } void KisView::paintopActivated(const KisID & paintop, const KisPaintOpSettings *paintopSettings) { if (paintop.id().isNull() || paintop.id().isEmpty()) { return; } m_paintop = paintop; m_paintopSettings = paintopSettings; emit paintopChanged(m_paintop, paintopSettings); notifyObservers(); } void KisView::setBGColor(const KisColor& c) { m_bg = c; notifyObservers(); emit sigBGQColorChanged( c.toTQColor() ); } void KisView::setFGColor(const KisColor& c) { m_fg = c; notifyObservers(); emit sigFGQColorChanged( c.toTQColor() ); } void KisView::slotSetFGColor(const KisColor& c) { m_fg = c; notifyObservers(); } void KisView::slotSetBGColor(const KisColor& c) { m_bg = c; notifyObservers(); } void KisView::slotSetFGQColor(const TQColor& c) { KisColorSpace * monitorSpace = KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA"), m_monitorProfile); setFGColor(KisColor(c, monitorSpace)); emit sigFGQColorChanged(c); } void KisView::slotSetBGQColor(const TQColor& c) { KisColorSpace * monitorSpace = KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA"), m_monitorProfile); setBGColor(KisColor(c, monitorSpace)); emit sigBGQColorChanged(c); } void KisView::setupPrinter(KPrinter& printer) { KisImageSP img = currentImg(); if (img) { printer.setPageSelection(KPrinter::ApplicationSide); printer.setPageSize(KPrinter::A4); printer.setOrientation(KPrinter::Portrait); } } void KisView::print(KPrinter& printer) { TQPainter gc(&printer); KisImageSP img = currentImg(); if (!img) return; printer.setFullPage(true); gc.setClipping(false); KisConfig cfg; TQString printerProfileName = cfg.printerProfile(); KisProfile * printerProfile = KisMetaRegistry::instance()->csRegistry() ->getProfileByName(printerProfileName); TQRect r = img->bounds(); img->renderToPainter(r.x(), r.y(), r.width(), r.height(), gc, printerProfile, KisImage::PAINT_IMAGE_ONLY, HDRExposure()); } void KisView::paintToolOverlay(const TQRegion& region) { if (!region.isEmpty() && m_toolManager->currentTool() && !m_toolIsPainting) { KisCanvasPainter gc(m_canvas); gc.setClipRegion(region); gc.setClipping(true); // Prevent endless loop if the tool needs to have the canvas repainted m_toolIsPainting = true; m_toolManager->currentTool()->paint(gc, region.boundingRect()); m_toolIsPainting = false; } } void KisView::canvasGotPaintEvent(TQPaintEvent *event) { if (m_canvas->isOpenGLCanvas()) { paintOpenGLView(event->rect()); } else { paintTQPaintDeviceView(event->region()); } } void KisView::canvasGotButtonPressEvent(KisButtonPressEvent *e) { #if defined(EXTENDED_X11_TABLET_SUPPORT) // The event filter doesn't see tablet events going to the canvas. if (e->device() != KisInputDevice::mouse()) { m_tabletEventTimer.start(); } #endif // EXTENDED_X11_TABLET_SUPPORT if (e->device() != currentInputDevice()) { if (e->device() == KisInputDevice::mouse()) { if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) { setInputDevice(KisInputDevice::mouse()); } } else { setInputDevice(e->device()); } } KisImageSP img = currentImg(); // if (img) { // TQPoint pt = mapToScreen(e->pos().floorTQPoint()); // KisGuideMgr *mgr = img->guides(); // // m_lastGuidePoint = mapToScreen(e->pos().floorTQPoint()); // m_currentGuide = 0; // // if ((e->state() & ~TQt::ShiftButton) == Qt::NoButton) { // KisGuideSP gd = mgr->find(static_cast(pt.x() / zoom()), static_cast(pt.y() / zoom()), TQMAX(2.0, 2.0 / zoom())); // // if (gd) { // m_currentGuide = gd; // // if ((e->button() == Qt::RightButton) || ((e->button() & TQt::ShiftButton) == TQt::ShiftButton)) { // if (gd->isSelected()) // mgr->unselect(gd); // else // mgr->select(gd); // } else { // if (!gd->isSelected()) { // mgr->unselectAll(); // mgr->select(gd); // } // } // // updateGuides(); // return; // } // } // } if (e->button() == Qt::RightButton) { TQPopupMenu * m_popup = 0; if (factory()) { Q_ASSERT(factory()); m_popup = (TQPopupMenu *)factory()->container("image_popup", this); } if (m_popup) { m_popup->popup(e->globalPos().roundTQPoint()); } } else if (e->device() == currentInputDevice() && m_toolManager->currentTool()) { KisPoint p = viewToWindow(e->pos()); // somewhat of a hack: we should actually test if we intersect with the scrollers, // but the globalPos seems to be off by a few pixels if (m_vScroll->draggingSlider() || m_hScroll->draggingSlider()) return; if (m_toolManager->currentTool()->wantsAutoScroll()) { enableAutoScroll(); } KisButtonPressEvent ev(e->device(), p, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->button(), e->state()); m_toolManager->currentTool()->buttonPress(&ev); } } void KisView::canvasGotMoveEvent(KisMoveEvent *e) { #if defined(EXTENDED_X11_TABLET_SUPPORT) // The event filter doesn't see tablet events going to the canvas. if (e->device() != KisInputDevice::mouse()) { m_tabletEventTimer.start(); } #endif // EXTENDED_X11_TABLET_SUPPORT if (e->device() != currentInputDevice()) { if (e->device() == KisInputDevice::mouse()) { if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) { setInputDevice(KisInputDevice::mouse()); } } else { setInputDevice(e->device()); } } KisImageSP img = currentImg(); m_hRuler->updatePointer(e->pos().floorX() - m_canvasXOffset, e->pos().floorY() - m_canvasYOffset); m_vRuler->updatePointer(e->pos().floorX() - m_canvasXOffset, e->pos().floorY() - m_canvasYOffset); KisPoint wp = viewToWindow(e->pos()); #if 0 if (img && m_currentGuide) { TQPoint p = mapToScreen(e->pos().floorTQPoint()); KisGuideMgr *mgr = img->guides(); if (((e->state() & Qt::LeftButton) == Qt::LeftButton) && mgr->hasSelected()) { eraseGuides(); p -= m_lastGuidePoint; if (p.x()) mgr->moveSelectedByX(p.x() / zoom()); if (p.y()) mgr->moveSelectedByY(p.y() / zoom()); m_doc->setModified(true); paintGuides(); } } else #endif if (e->device() == currentInputDevice() && m_toolManager->currentTool()) { KisMoveEvent ev(e->device(), wp, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->state()); m_toolManager->currentTool()->move(&ev); } // m_lastGuidePoint = mapToScreen(e->pos().floorTQPoint()); emit cursorPosition(wp.floorX(), wp.floorY()); } int KisView::leftBorder() const { return m_rulerThickness; } int KisView::rightBorder() const { return m_hScrollBarExtent; } int KisView::topBorder() const { return m_rulerThickness; } int KisView::bottomBorder() const { return m_vScrollBarExtent; } void KisView::mouseMoveEvent(TQMouseEvent *e) { KisMoveEvent ke(currentInputDevice(), KisPoint(e->pos()), KisPoint(e->globalPos()), PRESSURE_DEFAULT, 0, 0, e->state()); canvasGotMoveEvent(&ke); } void KisView::slotAutoScroll(const TQPoint &p) { scrollTo(horzValue()+p.x(), vertValue()+p.y()); } void KisView::canvasGotButtonReleaseEvent(KisButtonReleaseEvent *e) { #if defined(EXTENDED_X11_TABLET_SUPPORT) // The event filter doesn't see tablet events going to the canvas. if (e->device() != KisInputDevice::mouse()) { m_tabletEventTimer.start(); } #endif // EXTENDED_X11_TABLET_SUPPORT if (e->device() != currentInputDevice()) { if (e->device() == KisInputDevice::mouse()) { if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) { setInputDevice(KisInputDevice::mouse()); } } else { setInputDevice(e->device()); } } KisImageSP img = currentImg(); // if (img && m_currentGuide) { // m_currentGuide = 0; // } else if (e->device() == currentInputDevice() && m_toolManager->currentTool()) { KisPoint p = viewToWindow(e->pos()); KisButtonReleaseEvent ev(e->device(), p, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->button(), e->state()); disableAutoScroll(); if (m_toolManager->currentTool()) { m_toolManager->currentTool()->buttonRelease(&ev); } } } void KisView::canvasGotDoubleClickEvent(KisDoubleClickEvent *e) { #if defined(EXTENDED_X11_TABLET_SUPPORT) // The event filter doesn't see tablet events going to the canvas. if (e->device() != KisInputDevice::mouse()) { m_tabletEventTimer.start(); } #endif // EXTENDED_X11_TABLET_SUPPORT if (e->device() != currentInputDevice()) { if (e->device() == KisInputDevice::mouse()) { if (m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) { setInputDevice(KisInputDevice::mouse()); } } else { setInputDevice(e->device()); } } if (e->device() == currentInputDevice() && m_toolManager->currentTool()) { KisPoint p = viewToWindow(e->pos()); KisDoubleClickEvent ev(e->device(), p, e->globalPos(), e->pressure(), e->xTilt(), e->yTilt(), e->button(), e->state()); if (m_toolManager->currentTool()) { m_toolManager->currentTool()->doubleClick(&ev); } } } void KisView::canvasGotEnterEvent(TQEvent *e) { Q_UNUSED( e ); } void KisView::canvasGotLeaveEvent (TQEvent *e) { Q_UNUSED( e ); } void KisView::canvasGotMouseWheelEvent(TQWheelEvent *event) { //if(event->state() == ControlButton ) //{ if(event->delta() / 120 != 0) { if(event->delta() > 0) { zoomIn(); } else { zoomOut(); } if (m_oldTool) { KisCanvasPainter gc(m_canvas); m_oldTool->paint(gc); } } //} else { // TQApplication::sendEvent(m_vScroll, event); //} } void KisView::canvasGotKeyPressEvent(TQKeyEvent *event) { if (!m_toolManager->currentTool()) { event->ignore(); return; } if (event->key() == TQt::Key_Space) { if (!m_panning) { // Set tool temporarily to pan m_panning = true; m_oldTool = m_toolManager->currentTool(); m_toolManager->setCurrentTool( "tool_pan" ); } else { // Unset panning m_panning = false; m_toolManager->setCurrentTool( m_oldTool ); m_oldTool = 0; } } if (m_toolManager->currentTool()) m_toolManager->currentTool()->keyPress(event); } void KisView::canvasGotKeyReleaseEvent(TQKeyEvent *event) { if (m_toolManager->currentTool()) m_toolManager->currentTool()->keyRelease(event); } void KisView::canvasGotDragEnterEvent(TQDragEnterEvent *event) { bool accept = false; // Only accept drag if we're not busy, particularly as we may // be showing a progress bar and calling tqApp->processEvents(). if (KURLDrag::canDecode(event) && TQApplication::overrideCursor() == 0) { accept = true; } event->accept(accept); } void KisView::canvasGotDropEvent(TQDropEvent *event) { KURL::List urls; if (KURLDrag::decode(event, urls)) { if (urls.count() > 0) { enum enumActionId { addLayerId = 1, addDocumentId = 2, cancelId }; KPopupMenu popup(this, "drop_popup"); if (urls.count() == 1) { if (currentImg() != 0) { popup.insertItem(i18n("Insert as New Layer"), addLayerId); } popup.insertItem(i18n("Open in New Document"), addDocumentId); } else { if (currentImg() != 0) { popup.insertItem(i18n("Insert as New Layers"), addLayerId); } popup.insertItem(i18n("Open in New Documents"), addDocumentId); } popup.insertSeparator(); popup.insertItem(i18n("Cancel"), cancelId); int actionId = popup.exec(TQCursor::pos()); if (actionId >= 0 && actionId != cancelId) { for (KURL::List::ConstIterator it = urls.begin (); it != urls.end (); ++it) { KURL url = *it; switch (actionId) { case addLayerId: importImage(url); break; case addDocumentId: if (shell() != 0) { shell()->openDocument(url); } break; } } } } } } void KisView::layerProperties() { if (currentImg() && currentImg()->activeLayer()) showLayerProperties(currentImg()->activeLayer()); } namespace { class KisChangeFilterCmd : public KNamedCommand { typedef KNamedCommand super; public: // The TQStrings are the _serialized_ configs KisChangeFilterCmd(KisAdjustmentLayerSP layer, KisFilterConfiguration* config, const TQString& before, const TQString& after) : super(i18n("Change Filter")) { m_layer = layer; m_config = config; m_before = before; m_after = after; } public: virtual void execute() { TQApplication::setOverrideCursor(KisCursor::waitCursor()); m_config->fromXML(m_after); //Q_ASSERT(m_after == m_config->toString()); m_layer->setFilter(m_config); m_layer->setDirty(); TQApplication::restoreOverrideCursor(); } virtual void unexecute() { TQApplication::setOverrideCursor(KisCursor::waitCursor()); m_config->fromXML(m_before); //Q_ASSERT(m_before == m_config->toString()); m_layer->setFilter(m_config); m_layer->setDirty(); TQApplication::restoreOverrideCursor(); } private: KisAdjustmentLayerSP m_layer; KisFilterConfiguration* m_config; TQString m_before; TQString m_after; }; } void KisView::showLayerProperties(KisLayerSP layer) { Q_ASSERT( layer ); if ( !layer ) return; KisColorSpace * cs = 0; KisPaintLayer * pl = dynamic_cast( layer.data() ); if ( pl ) { cs = pl->paintDevice()->colorSpace(); } else { cs = layer->image()->colorSpace(); } if (KisAdjustmentLayerSP alayer = dynamic_cast(layer.data())) { KisDlgAdjLayerProps dlg(alayer, alayer->name(), i18n("Adjustment Layer Properties"), this, "dlgadjlayerprops"); TQString before = dlg.filterConfiguration()->toString(); if (dlg.exec() == TQDialog::Accepted) { KisChangeFilterCmd * cmd = new KisChangeFilterCmd(alayer, dlg.filterConfiguration(), before, dlg.filterConfiguration()->toString()); cmd->execute(); m_adapter->addCommand(cmd); m_doc->setModified( true ); } } else { KisDlgLayerProperties dlg(layer->name(), layer->opacity(), layer->compositeOp(), cs); if (dlg.exec() == TQDialog::Accepted) { if (layer->name() != dlg.getName() || layer->opacity() != dlg.getOpacity() || layer->compositeOp() != dlg.getCompositeOp()) { TQApplication::setOverrideCursor(KisCursor::waitCursor()); m_adapter->beginMacro(i18n("Property Changes")); layer->image()->setLayerProperties(layer, dlg.getOpacity(), dlg.getCompositeOp(), dlg.getName()); layer->setDirty(); m_adapter->endMacro(); TQApplication::restoreOverrideCursor(); m_doc->setModified( true ); } } } } void KisView::layerAdd() { KisImageSP img = currentImg(); if (img && img->activeLayer()) { addLayer(img->activeLayer()->parent(), img->activeLayer()); } else if (img) addLayer(static_cast(img->rootLayer().data()), 0); } void KisView::addLayer(KisGroupLayerSP parent, KisLayerSP above) { KisImageSP img = currentImg(); if (img) { KisConfig cfg; TQString profilename; if(img->colorSpace()->getProfile()) profilename = img->colorSpace()->getProfile()->productName(); NewLayerDialog dlg(img->colorSpace()->id(), profilename, img->nextLayerName(), this); if (dlg.exec() == TQDialog::Accepted) { KisColorSpace* cs = KisMetaRegistry::instance()-> csRegistry() -> getColorSpace(dlg.colorSpaceID(),dlg.profileName()); KisLayerSP layer = new KisPaintLayer(img, dlg.layerName(), dlg.opacity(), cs); if (layer) { layer->setCompositeOp(dlg.compositeOp()); img->addLayer(layer, parent.data(), above); updateCanvas(); } else { KMessageBox::error(this, i18n("Could not add layer to image."), i18n("Layer Error")); } } else { img->rollBackLayerName(); } } } void KisView::addGroupLayer(KisGroupLayerSP parent, KisLayerSP above) { KisImageSP img = currentImg(); if (img) { TQString profilename; if(img->colorSpace()->getProfile()) profilename = img->colorSpace()->getProfile()->productName(); KisConfig cfg; NewLayerDialog dlg(img->colorSpace()->id(), profilename, img->nextLayerName(), this); dlg.setColorSpaceEnabled(false); if (dlg.exec() == TQDialog::Accepted) { KisLayerSP layer = new KisGroupLayer(img, dlg.layerName(), dlg.opacity()); if (layer) { layer->setCompositeOp(dlg.compositeOp()); img->addLayer(layer, parent.data(), above); updateCanvas(); } else { KMessageBox::error(this, i18n("Could not add layer to image."), i18n("Layer Error")); } } } } void KisView::addPartLayer() { KisImageSP img = currentImg(); if (!img) return; addPartLayer(img->rootLayer(), img->rootLayer()->firstChild(), m_actionPartLayer->documentEntry()); } void KisView::addPartLayer(KisGroupLayerSP parent, KisLayerSP above, const KoDocumentEntry& entry) { delete m_partHandler; // Only one at a time m_partHandler = new KisPartLayerHandler(this, entry, parent, above); disconnect(m_canvas, TQT_SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)), this, 0); disconnect(m_canvas, TQT_SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)), this, 0); disconnect(m_canvas, TQT_SIGNAL(sigGotMoveEvent(KisMoveEvent*)), this, 0); disconnect(m_canvas, TQT_SIGNAL(sigGotKeyPressEvent(TQKeyEvent*)), this, 0); connect(m_canvas, TQT_SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)), m_partHandler, TQT_SLOT(gotButtonPressEvent(KisButtonPressEvent*))); connect(m_canvas, TQT_SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)), m_partHandler, TQT_SLOT(gotButtonReleaseEvent(KisButtonReleaseEvent*))); connect(m_canvas, TQT_SIGNAL(sigGotMoveEvent(KisMoveEvent*)), m_partHandler, TQT_SLOT(gotMoveEvent(KisMoveEvent*))); connect(m_canvas, TQT_SIGNAL(sigGotKeyPressEvent(TQKeyEvent*)), m_partHandler, TQT_SLOT(gotKeyPressEvent(TQKeyEvent*))); connect(m_partHandler, TQT_SIGNAL(sigGotMoveEvent(KisMoveEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotMoveEvent(KisMoveEvent*))); connect(m_partHandler, TQT_SIGNAL(sigGotKeyPressEvent(TQKeyEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotKeyPressEvent(TQKeyEvent*))); connect(m_partHandler, TQT_SIGNAL(handlerDone()), TQT_TQOBJECT(this), TQT_SLOT(reconnectAfterPartInsert())); } void KisView::insertPart(const TQRect& viewRect, const KoDocumentEntry& entry, KisGroupLayerSP parent, KisLayerSP above) { KisImageSP img = currentImg(); if (!img) return; KoDocument* doc = entry.createDoc(m_doc); if ( !doc ) return; if ( !doc->showEmbedInitDialog(this) ) return; TQRect rect = viewToWindow(viewRect); KisChildDoc * childDoc = m_doc->createChildDoc(rect, doc); KisPartLayerImpl* partLayer = new KisPartLayerImpl(img, childDoc); partLayer->setDocType(entry.service()->genericName()); img->addLayer(partLayer, parent, above); m_doc->setModified(true); reconnectAfterPartInsert(); } void KisView::reconnectAfterPartInsert() { connect(m_canvas, TQT_SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotButtonPressEvent(KisButtonPressEvent*))); connect(m_canvas, TQT_SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotButtonReleaseEvent(KisButtonReleaseEvent*))); connect(m_canvas, TQT_SIGNAL(sigGotMoveEvent(KisMoveEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotMoveEvent(KisMoveEvent*))); connect(m_canvas, TQT_SIGNAL(sigGotKeyPressEvent(TQKeyEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotKeyPressEvent(TQKeyEvent*))); delete m_partHandler; m_partHandler = 0; } void KisView::addAdjustmentLayer() { KisImageSP img = currentImg(); if (!img) return; addAdjustmentLayer( img->activeLayer()->parent(), img->activeLayer() ); } void KisView::addAdjustmentLayer(KisGroupLayerSP parent, KisLayerSP above) { Q_ASSERT(parent); Q_ASSERT(above); KisImageSP img = currentImg(); if (!img) return; KisLayerSP l = img->activeLayer(); KisPaintDeviceSP dev; // Argh! I hate having to cast, cast and cast again to see what kind of a layer I've got! KisPaintLayer * pl = dynamic_cast(l.data()); if (pl) { dev = pl->paintDevice(); } else { KisGroupLayer * gl = dynamic_cast(l.data()); if (gl) { dev = gl->projection(img->bounds()); } else { KisAdjustmentLayer * al = dynamic_cast(l.data()); if (al) { dev = al->cachedPaintDevice(); } else { return; } } } KisDlgAdjustmentLayer dlg(img, img->nextLayerName(), i18n("New Adjustment Layer"), this, "dlgadjustmentlayer"); if (dlg.exec() == TQDialog::Accepted) { KisSelectionSP selection = 0; if (dev->hasSelection()) { selection = dev->selection(); } KisFilterConfiguration * filter = dlg.filterConfiguration(); TQString name = dlg.layerName(); addAdjustmentLayer( parent, above, name, filter, selection); } } void KisView::addAdjustmentLayer(KisGroupLayerSP parent, KisLayerSP above, const TQString & name, KisFilterConfiguration * filter, KisSelectionSP selection) { Q_ASSERT(parent); Q_ASSERT(above); Q_ASSERT(filter); KisImageSP img = currentImg(); if (!img) return; KisAdjustmentLayer * l = new KisAdjustmentLayer(img, name, filter, selection); img->addLayer(l, parent, above); } void KisView::slotChildActivated(bool a) { // It should be so that the only part (child) we can activate, is the current layer: if (currentImg() && currentImg()->activeLayer()) { if (a) { currentImg()->activeLayer()->activate(); } else { currentImg()->activeLayer()->deactivate(); } } super::slotChildActivated(a); } void KisView::layerRemove() { KisImageSP img = currentImg(); if (img) { KisLayerSP layer = img->activeLayer(); if (layer) { img->removeLayer(layer); if (layer->parent()) layer->parent()->setDirty(layer->extent()); updateCanvas(); layerUpdateGUI(img->activeLayer() != 0); } } } void KisView::layerDuplicate() { KisImageSP img = currentImg(); if (!img) return; KisLayerSP active = img->activeLayer(); if (!active) return; KisLayerSP dup = active->clone(); dup->setName(i18n("Duplicate of '%1'").arg(active->name())); img->addLayer(dup, active->parent().data(), active); if (dup) { img->activate( dup ); updateCanvas(); } else { KMessageBox::error(this, i18n("Could not add layer to image."), i18n("Layer Error")); } } void KisView::layerRaise() { KisImageSP img = currentImg(); KisLayerSP layer; if (!img) return; layer = img->activeLayer(); img->raiseLayer(layer); } void KisView::layerLower() { KisImageSP img = currentImg(); KisLayerSP layer; if (!img) return; layer = img->activeLayer(); img->lowerLayer(layer); } void KisView::layerFront() { KisImageSP img = currentImg(); KisLayerSP layer; if (!img) return; layer = img->activeLayer(); img->toTop(layer); } void KisView::layerBack() { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer; layer = img->activeLayer(); img->toBottom(layer); } void KisView::layersUpdated() { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); layerUpdateGUI(img && layer); notifyObservers(); } void KisView::layerToggleVisible() { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); if (!layer) return; layer->setVisible(!layer->visible()); } void KisView::layerToggleLocked() { KisImageSP img = currentImg(); if (!img) return; KisLayerSP layer = img->activeLayer(); if (!layer) return; layer->setLocked(!layer->locked()); } void KisView::actLayerVisChanged(int show) { m_actLayerVis = (show != 0); } bool KisView::activeLayerHasSelection() { return m_image && m_image->activeDevice() && m_image->activeDevice()->hasSelection(); } void KisView::scrollH(int value) { m_hRuler->updateVisibleArea(value, 0); int xShift = m_scrollX - value; m_scrollX = value; if (m_canvas->isUpdatesEnabled()) { if (xShift > 0) { if (m_canvas->isOpenGLCanvas()) { paintOpenGLView(TQRect(0, 0, m_canvas->width(), m_canvas->height())); } else { TQRect drawRect(0, 0, xShift, m_canvasPixmap.height()); bitBlt(&m_canvasPixmap, xShift, 0, &m_canvasPixmap, 0, 0, m_canvasPixmap.width() - xShift, m_canvasPixmap.height()); updateTQPaintDeviceCanvas(viewToWindow(drawRect)); m_canvas->repaint(); } } else if (xShift < 0) { TQRect drawRect(m_canvasPixmap.width() + xShift, 0, -xShift, m_canvasPixmap.height()); if (m_canvas->isOpenGLCanvas()) { paintOpenGLView(TQRect(0, 0, m_canvas->width(), m_canvas->height())); } else { bitBlt(&m_canvasPixmap, 0, 0, &m_canvasPixmap, -xShift, 0, m_canvasPixmap.width() + xShift, m_canvasPixmap.height()); updateTQPaintDeviceCanvas(viewToWindow(drawRect)); m_canvas->repaint(); } } if (m_oldTool) { KisCanvasPainter gc(m_canvas); m_oldTool->paint(gc); } } if (xShift != 0) { // XXX do sth with the childframe or so } emit viewTransformationsChanged(); } void KisView::scrollV(int value) { m_vRuler->updateVisibleArea(0, value); int yShift = m_scrollY - value; m_scrollY = value; if (m_canvas->isUpdatesEnabled()) { if (yShift > 0) { if (m_canvas->isOpenGLCanvas()) { paintOpenGLView(TQRect(0, 0, m_canvas->width(), m_canvas->height())); } else { TQRect drawRect(0, 0, m_canvasPixmap.width(), yShift); bitBlt(&m_canvasPixmap, 0, yShift, &m_canvasPixmap, 0, 0, m_canvasPixmap.width(), m_canvasPixmap.height() - yShift); updateTQPaintDeviceCanvas(viewToWindow(drawRect)); m_canvas->repaint(); } } else if (yShift < 0) { if (m_canvas->isOpenGLCanvas()) { paintOpenGLView(TQRect(0, 0, m_canvas->width(), m_canvas->height())); } else { TQRect drawRect(0, m_canvasPixmap.height() + yShift, m_canvasPixmap.width(), -yShift); bitBlt(&m_canvasPixmap, 0, 0, &m_canvasPixmap, 0, -yShift, m_canvasPixmap.width(), m_canvasPixmap.height() + yShift); updateTQPaintDeviceCanvas(viewToWindow(drawRect)); m_canvas->repaint(); } } if (m_oldTool) { KisCanvasPainter gc(m_canvas); m_oldTool->paint(gc); } } if (yShift != 0) { // XXX do sth with the childframe or so } emit viewTransformationsChanged(); } void KisView::setupCanvas() { m_canvas = new KisCanvas(this, "kis_canvas"); m_canvas->setFocusPolicy( TQ_StrongFocus ); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotButtonPressEvent(KisButtonPressEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotButtonPressEvent(KisButtonPressEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotButtonReleaseEvent(KisButtonReleaseEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotButtonReleaseEvent(KisButtonReleaseEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotDoubleClickEvent(KisDoubleClickEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotDoubleClickEvent(KisDoubleClickEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotMoveEvent(KisMoveEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotMoveEvent(KisMoveEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotPaintEvent(TQPaintEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotPaintEvent(TQPaintEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotEnterEvent(TQEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotEnterEvent(TQEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotLeaveEvent(TQEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotLeaveEvent(TQEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotMouseWheelEvent(TQWheelEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotMouseWheelEvent(TQWheelEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotKeyPressEvent(TQKeyEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotKeyPressEvent(TQKeyEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotKeyReleaseEvent(TQKeyEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotKeyReleaseEvent(TQKeyEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotDragEnterEvent(TQDragEnterEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotDragEnterEvent(TQDragEnterEvent*))); TQObject::connect(m_canvas, TQT_SIGNAL(sigGotDropEvent(TQDropEvent*)), TQT_TQOBJECT(this), TQT_SLOT(canvasGotDropEvent(TQDropEvent*))); } void KisView::connectCurrentImg() { if (m_image) { connect(m_image, TQT_SIGNAL(sigActiveSelectionChanged(KisImageSP)), m_selectionManager, TQT_SLOT(imgSelectionChanged(KisImageSP))); connect(m_image, TQT_SIGNAL(sigActiveSelectionChanged(KisImageSP)), TQT_TQOBJECT(this), TQT_SLOT(updateCanvas())); connect(m_image, TQT_SIGNAL(sigColorSpaceChanged(KisColorSpace *)), TQT_TQOBJECT(this), TQT_SLOT(updateStatusBarProfileLabel())); connect(m_image, TQT_SIGNAL(sigProfileChanged(KisProfile * )), TQT_SLOT(profileChanged(KisProfile * ))); connect(m_image, TQT_SIGNAL(sigLayersChanged(KisGroupLayerSP)), TQT_SLOT(layersUpdated())); connect(m_image, TQT_SIGNAL(sigMaskInfoChanged()), TQT_SLOT(maskUpdated())); connect(m_image, TQT_SIGNAL(sigLayerAdded(KisLayerSP)), TQT_SLOT(layersUpdated())); connect(m_image, TQT_SIGNAL(sigLayerRemoved(KisLayerSP, KisGroupLayerSP, KisLayerSP)), TQT_SLOT(layersUpdated())); connect(m_image, TQT_SIGNAL(sigLayerMoved(KisLayerSP, KisGroupLayerSP, KisLayerSP)), TQT_SLOT(layersUpdated())); connect(m_image, TQT_SIGNAL(sigLayerActivated(KisLayerSP)), TQT_SLOT(layersUpdated())); connect(m_image, TQT_SIGNAL(sigLayerActivated(KisLayerSP)), TQT_SLOT(updateCanvas())); connect(m_image, TQT_SIGNAL(sigLayerPropertiesChanged(KisLayerSP)), TQT_SLOT(layersUpdated())); KisConnectPartLayerVisitor v(m_image, this, true); m_image->rootLayer()->accept(v); connect(m_image, TQT_SIGNAL(sigLayerAdded(KisLayerSP)), TQT_SLOT(handlePartLayerAdded(KisLayerSP))); maskUpdated(); #ifdef HAVE_GL if (m_OpenGLImageContext != 0) { connect(m_OpenGLImageContext, TQT_SIGNAL(sigImageUpdated(TQRect)), TQT_SLOT(slotOpenGLImageUpdated(TQRect))); connect(m_OpenGLImageContext, TQT_SIGNAL(sigSizeChanged(TQ_INT32, TQ_INT32)), TQT_SLOT(slotImageSizeChanged(TQ_INT32, TQ_INT32))); } else #endif { connect(m_image, TQT_SIGNAL(sigImageUpdated(TQRect)), TQT_SLOT(imgUpdated(TQRect))); connect(m_image, TQT_SIGNAL(sigSizeChanged(TQ_INT32, TQ_INT32)), TQT_SLOT(slotImageSizeChanged(TQ_INT32, TQ_INT32))); } } m_layerBox->setImage(m_image); m_birdEyeBox->setImage(m_image); } void KisView::disconnectCurrentImg() { if (m_image) { m_image->disconnect(this); m_layerBox->setImage(0); m_birdEyeBox->setImage(0); KisConnectPartLayerVisitor v(m_image, this, false); m_image->rootLayer()->accept(v); } #ifdef HAVE_GL if (m_OpenGLImageContext != 0) { m_OpenGLImageContext->disconnect(this); } #endif } void KisView::handlePartLayerAdded(KisLayerSP layer) { KisPartLayer* l = dynamic_cast(layer.data()); if (!l) return; connect(TQT_TQOBJECT(this), TQT_SIGNAL(childActivated(KoDocumentChild*)), layer, TQT_SLOT(childActivated(KoDocumentChild*))); } void KisView::imgUpdated(TQRect rc) { updateCanvas(rc); } void KisView::slotOpenGLImageUpdated(TQRect rc) { paintOpenGLView(windowToView(rc)); } void KisView::profileChanged(KisProfile * /*profile*/) { updateStatusBarProfileLabel(); } void KisView::slotImageSizeChanged(TQ_INT32 /*w*/, TQ_INT32 /*h*/) { resizeEvent(0); refreshKisCanvas(); } void KisView::resizeCurrentImage(TQ_INT32 w, TQ_INT32 h, bool cropLayers) { if (!currentImg()) return; currentImg()->resize(w, h, cropLayers); m_doc->setModified(true); layersUpdated(); } void KisView::scaleCurrentImage(double sx, double sy, KisFilterStrategy *filterStrategy) { if (!currentImg()) return; currentImg()->scale(sx, sy, m_progress, filterStrategy); m_doc->setModified(true); layersUpdated(); } void KisView::rotateCurrentImage(double radians) { if (!currentImg()) return; currentImg()->rotate(radians, m_progress); m_doc->setModified(true); layersUpdated(); } void KisView::shearCurrentImage(double angleX, double angleY) { if (!currentImg()) return; currentImg()->shear(angleX, angleY, m_progress); m_doc->setModified(true); layersUpdated(); } TQPoint KisView::viewToWindow(const TQPoint& pt) { TQPoint converted; converted.rx() = static_cast((pt.x() + horzValue()) / zoom()); converted.ry() = static_cast((pt.y() + vertValue()) / zoom()); return converted; } TQPoint KisView::viewToWindow(const TQPoint& pt) const { TQPoint converted; converted.rx() = static_cast((pt.x() + horzValue()) / zoom()); converted.ry() = static_cast((pt.y() + vertValue()) / zoom()); return converted; } KisPoint KisView::viewToWindow(const KisPoint& pt) { KisPoint converted; converted.setX((pt.x() + horzValue()) / zoom()); converted.setY((pt.y() + vertValue()) / zoom()); return converted; } TQRect KisView::viewToWindow(const TQRect& rc) { TQRect r; r.setTopLeft(viewToWindow(rc.topLeft())); r.setRight((int)(ceil((rc.right() + 1.0 + horzValue()) / zoom()) - 1)); r.setBottom((int)(ceil((rc.bottom() + 1.0 + vertValue()) / zoom()) - 1)); return r; } KisRect KisView::viewToWindow(const KisRect& rc) { KisRect r; KisPoint p = viewToWindow(KisPoint(rc.x(), rc.y())); r.setX(p.x()); r.setY(p.y()); r.setWidth(rc.width() / zoom()); r.setHeight(rc.height() / zoom()); return r; } void KisView::viewToWindow(TQ_INT32 *x, TQ_INT32 *y) { if (x && y) { TQPoint p = viewToWindow(TQPoint(*x, *y)); *x = p.x(); *y = p.y(); } } TQPoint KisView::windowToView(const TQPoint& pt) { TQPoint p; p.setX(static_cast(pt.x() * zoom() - horzValue())); p.setY(static_cast(pt.y() * zoom() - vertValue())); return p; } TQPoint KisView::windowToView(const TQPoint& pt) const { TQPoint p; p.setX(static_cast(pt.x() * zoom() - horzValue())); p.setY(static_cast(pt.y() * zoom() - vertValue())); return p; } KisPoint KisView::windowToView(const KisPoint& pt) { KisPoint p; p.setX(pt.x() * zoom() - horzValue()); p.setY(pt.y() * zoom() - vertValue()); return p; } TQRect KisView::windowToView(const TQRect& rc) { TQRect r; r.setTopLeft(windowToView(rc.topLeft())); r.setRight((int)(ceil((rc.right() + 1.0) * zoom()) - horzValue() - 1)); r.setBottom((int)(ceil((rc.bottom() + 1.0) * zoom()) - vertValue() - 1)); return r; } KisRect KisView::windowToView(const KisRect& rc) { KisRect r; KisPoint p = windowToView(KisPoint(rc.x(), rc.y())); r.setX(p.x()); r.setY(p.y()); r.setWidth(rc.width() * zoom()); r.setHeight(rc.height() * zoom()); return r; } void KisView::windowToView(TQ_INT32 *x, TQ_INT32 *y) { if (x && y) { TQPoint p = windowToView(TQPoint(*x, *y)); *x = p.x(); *y = p.y(); } } void KisView::guiActivateEvent(KParts::GUIActivateEvent *event) { Q_ASSERT(event); if (event->activated()) { KStatusBar *sb = statusBar(); if (sb) { sb->show(); } if (!m_guiActivateEventReceived) { m_guiActivateEventReceived = true; startInitialZoomTimerIfReady(); } } super::guiActivateEvent(event); } bool KisView::eventFilter(TQObject *o, TQEvent *e) { Q_ASSERT(o); Q_ASSERT(e); switch (e->type()) { case TQEvent::TabletMove: case TQEvent::TabletPress: case TQEvent::TabletRelease: { TQTabletEvent *te = TQT_TQTABLETEVENT(e); KisInputDevice device; switch (te->device()) { default: case TQTabletEvent::Stylus: case TQTabletEvent::NoDevice: device = KisInputDevice::stylus(); break; case TQTabletEvent::Puck: device = KisInputDevice::puck(); break; case TQTabletEvent::Eraser: device = KisInputDevice::eraser(); break; } setInputDevice(device); // We ignore device change due to mouse events for a short duration // after a tablet event, since these are almost certainly mouse events // sent to receivers that don't accept the tablet event. m_tabletEventTimer.start(); break; } case TQEvent::MouseButtonPress: case TQEvent::MouseMove: case TQEvent::MouseButtonRelease: { #ifdef EXTENDED_X11_TABLET_SUPPORT KisInputDevice device = KisCanvasWidget::findActiveInputDevice(); if (device != KisInputDevice::mouse()) { setInputDevice(device); m_tabletEventTimer.start(); } else #endif { if (currentInputDevice() != KisInputDevice::mouse() && m_tabletEventTimer.elapsed() > MOUSE_CHANGE_EVENT_DELAY) { setInputDevice(KisInputDevice::mouse()); } } break; } case TQEvent::KeyPress: case TQEvent::KeyRelease: { if (m_canvas->cursorIsOverCanvas()) { m_canvas->handleKeyEvent(e); return true; } break; } #if 0 // This code is unnecessary now that there's an application event filter // This eventFilter is called for all widgets already, no need to install event filters multiple times // Even worse: with multiple views, they would all install event filters on each other's widgets, // due to the qapp event filter triggering in all views! case TQEvent::ChildInserted: { TQChildEvent *childEvent = static_cast(e); TQObject *child = childEvent->child(); if ( child->isWidgetType() ) { child->installEventFilter(this); TQObjectList *objectList = child->queryList(TQWIDGET_OBJECT_NAME_STRING); TQObjectListIt it(*objectList); TQObject *obj; while ((obj = it.current()) != 0) { obj->installEventFilter(this); ++it; } delete objectList; } } #endif default: // Ignore break; } #if 0 if ((o == m_hRuler || o == m_vRuler) && (e->type() == TQEvent::MouseMove || e->type() == TQEvent::MouseButtonRelease)) { TQMouseEvent *me = dynamic_cast(e); TQPoint pt = mapFromGlobal(me->globalPos()); KisImageSP img = currentImg(); KisGuideMgr *mgr; if (!img) return super::eventFilter(o, e); mgr = img->guides(); if (e->type() == TQEvent::MouseMove && (me->state() & Qt::LeftButton)) { bool flag = geometry().contains(pt); KisGuideSP gd; if (m_currentGuide == 0 && flag) { // No guide is being edited and moving mouse over the canvas. // Create a new guide. enterEvent(0); eraseGuides(); mgr->unselectAll(); if (o == m_vRuler) gd = mgr->add((pt.x() - m_vRuler->width() + horzValue()) / zoom(), Qt::Vertical); else gd = mgr->add((pt.y() - m_hRuler->height() + vertValue()) / zoom(), Qt::Horizontal); m_currentGuide = gd; mgr->select(gd); m_lastGuidePoint = mapToScreen(pt); } else if (m_currentGuide) { if (flag) { // moved an existing guide. KisMoveEvent kme(currentInputDevice(), pt, me->globalPos(), PRESSURE_DEFAULT, 0, 0, me->state()); canvasGotMoveEvent(&kme); } else { // moved a guide out of the frame, destroy it leaveEvent(0); eraseGuides(); mgr->remove(m_currentGuide); paintGuides(); m_currentGuide = 0; } } } else if (e->type() == TQEvent::MouseButtonRelease && m_currentGuide) { eraseGuides(); mgr->unselect(m_currentGuide); paintGuides(); m_currentGuide = 0; enterEvent(0); KisMoveEvent kme(currentInputDevice(), pt, me->globalPos(), PRESSURE_DEFAULT, 0, 0, Qt::NoButton); canvasGotMoveEvent(&kme); } } #endif return super::eventFilter(o, e); } #if 0 void KisView::eraseGuides() { KisImageSP img = currentImg(); if (img) { KisGuideMgr *mgr = img->guides(); if (mgr) mgr->erase(&m_canvasPixmap, this, horzValue(), vertValue(), zoom()); } } void KisView::paintGuides() { KisImageSP img = currentImg(); if (img) { KisGuideMgr *mgr = img->guides(); if (mgr) mgr->paint(&m_canvasPixmap, this, horzValue(), vertValue(), zoom()); } } void KisView::updateGuides() { eraseGuides(); paintGuides(); } #endif //void KisView::viewGuideLines() //{ //} TQPoint KisView::mapToScreen(const TQPoint& pt) { TQPoint converted; converted.rx() = pt.x() + horzValue(); converted.ry() = pt.y() + vertValue(); return converted; } void KisView::attach(KisCanvasObserver *observer) { Q_ASSERT(observer); if (observer) m_observers.push_back(observer); } void KisView::detach(KisCanvasObserver *observer) { Q_ASSERT(observer); if (observer) { vKisCanvasObserver_it it = std::find(m_observers.begin(), m_observers.end(), observer); if (it != m_observers.end()) m_observers.erase(it); } } void KisView::notifyObservers() { for (vKisCanvasObserver_it it = m_observers.begin(); it != m_observers.end(); ++it) { (*it)->update(this); } } KisImageSP KisView::currentImg() const { return m_image; } void KisView::setCurrentImage(KisImageSP image) { if(!image) return; disconnectCurrentImg(); m_image = image; KisConfig cfg; #ifdef HAVE_GL if (cfg.useOpenGL()) { m_OpenGLImageContext = KisOpenGLImageContext::getImageContext(image, monitorProfile()); m_canvas->createOpenGLCanvas(m_OpenGLImageContext->sharedContextWidget()); } #endif connectCurrentImg(); m_layerBox->setImage(currentImg()); zoomAroundPoint(0, 0, 1.0); if (!currentImg()) layersUpdated(); imgUpdateGUI(); image->blockSignals(false); } KisColor KisView::bgColor() const { return m_bg; } KisColor KisView::fgColor() const { return m_fg; } KisBrush *KisView::currentBrush() const { return m_brush; } KisPattern *KisView::currentPattern() const { return m_pattern; } KisGradient *KisView::currentGradient() const { return m_gradient; } KisID KisView::currentPaintop() const { return m_paintop; } const KisPaintOpSettings *KisView::currentPaintopSettings() const { return m_paintopSettings; } double KisView::zoomFactor() const { return zoom(); } KisUndoAdapter *KisView::undoAdapter() const { return m_adapter; } KisCanvasController *KisView::canvasController() const { return const_cast(static_cast(this)); } KisToolControllerInterface *KisView::toolController() const { return const_cast(static_cast(m_toolManager)); } KisDoc *KisView::document() const { return m_doc; } KisProgressDisplayInterface *KisView::progressDisplay() const { return m_progress; } TQCursor KisView::setCanvasCursor(const TQCursor & cursor) { TQCursor oldCursor = m_canvas->cursor(); TQCursor newCursor; KisConfig cfg; switch (cfg.cursorStyle()) { case CURSOR_STYLE_TOOLICON: newCursor = cursor; break; case CURSOR_STYLE_CROSSHAIR: newCursor = KisCursor::crossCursor(); break; case CURSOR_STYLE_POINTER: newCursor = KisCursor::arrowCursor(); break; case CURSOR_STYLE_OUTLINE: newCursor = cursor; break; default: newCursor = cursor; } m_canvas->setCursor(newCursor); return oldCursor; } float KisView::HDRExposure() const { return m_HDRExposure; } void KisView::setHDRExposure(float exposure) { if (exposure != m_HDRExposure) { m_HDRExposure = exposure; notifyObservers(); updateCanvas(); } } void KisView::createDockers() { m_birdEyeBox = new KisBirdEyeBox(this); m_birdEyeBox->setCaption(i18n("Overview")); m_paletteManager->addWidget( m_birdEyeBox, "birdeyebox", chalk::CONTROL_PALETTE); m_hsvwidget = new KoHSVWidget(this, "hsv"); m_hsvwidget->setCaption(i18n("HSV")); connect(m_hsvwidget, TQT_SIGNAL(sigFgColorChanged(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetFGQColor(const TQColor &))); connect(m_hsvwidget, TQT_SIGNAL(sigBgColorChanged(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetBGQColor(const TQColor &))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(sigFGQColorChanged(const TQColor &)), m_hsvwidget, TQT_SLOT(setFgColor(const TQColor &))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(sigBGQColorChanged(const TQColor &)), m_hsvwidget, TQT_SLOT(setBgColor(const TQColor &))); m_paletteManager->addWidget( m_hsvwidget, "hsvwidget", chalk::COLORBOX, 0, PALETTE_DOCKER, true); m_rgbwidget = new KoRGBWidget(this, "rgb"); m_rgbwidget->setCaption(i18n("RGB")); connect(m_rgbwidget, TQT_SIGNAL(sigFgColorChanged(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetFGQColor(const TQColor &))); connect(m_rgbwidget, TQT_SIGNAL(sigBgColorChanged(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetBGQColor(const TQColor &))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(sigFGQColorChanged(const TQColor &)), m_rgbwidget, TQT_SLOT(setFgColor(const TQColor &))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(sigBGQColorChanged(const TQColor &)), m_rgbwidget, TQT_SLOT(setBgColor(const TQColor &))); m_paletteManager->addWidget( m_rgbwidget, "rgbwidget", chalk::COLORBOX); m_graywidget = new KoGrayWidget(this, "gray"); m_graywidget->setCaption(i18n("Gray")); connect(m_graywidget, TQT_SIGNAL(sigFgColorChanged(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetFGQColor(const TQColor &))); connect(m_graywidget, TQT_SIGNAL(sigBgColorChanged(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetBGQColor(const TQColor &))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(sigFGQColorChanged(const TQColor &)), m_graywidget, TQT_SLOT(setFgColor(const TQColor &))); connect(TQT_TQOBJECT(this), TQT_SIGNAL(sigBGQColorChanged(const TQColor &)), m_graywidget, TQT_SLOT(setBgColor(const TQColor &))); m_paletteManager->addWidget( m_graywidget, "graywidget", chalk::COLORBOX); //make sure the color chooser get right default values emit sigFGQColorChanged(m_fg.toTQColor()); emit sigBGQColorChanged(m_bg.toTQColor()); m_palettewidget = new KisPaletteWidget(this); m_palettewidget->setCaption(i18n("Palettes")); connect(m_palettewidget, TQT_SIGNAL(colorSelected(const TQColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetFGQColor(const TQColor &))); // No BGColor or reverse slotFGChanged->palette connections, since that's not useful here KisResourceServerBase* rServer; rServer = KisResourceServerRegistry::instance()->get("PaletteServer"); TQValueList resources = rServer->resources(); TQValueList::iterator it; for ( it = resources.begin(); it != resources.end(); ++it ) { m_palettewidget->slotAddPalette( *it ); } connect(m_palettewidget, TQT_SIGNAL(colorSelected(const KisColor &)), TQT_TQOBJECT(this), TQT_SLOT(slotSetFGColor(const KisColor &))); m_paletteManager->addWidget( m_palettewidget, "palettewidget", chalk::COLORBOX, 10, PALETTE_DOCKER, true); } TQPoint KisView::applyViewTransformations(const TQPoint& p) const { TQPoint point(windowToView(p)); if (m_hRuler->isShown()) point.ry() += m_hRuler->height(); if (m_vRuler -> isShown()) point.rx() += m_vRuler->width(); return point; } TQPoint KisView::reverseViewTransformations(const TQPoint& p) const { // Since we now zoom ourselves, the only thing super::~ does is nothing anymore. // Hence, zoom ourselves, like super would // viewToWindow doesn't take the rulers into account, do that ourselves TQPoint point(p); if (m_hRuler -> isShown()) point.ry() -= m_hRuler -> height(); if (m_vRuler -> isShown()) point.rx() -= m_vRuler -> width(); return viewToWindow(point); } void KisView::canvasAddChild(KoViewChild *child) { super::canvasAddChild(child); connect(TQT_TQOBJECT(this), TQT_SIGNAL(viewTransformationsChanged()), child, TQT_SLOT(reposition())); m_vScroll->raise(); m_hScroll->raise(); m_vScroll->raise(); m_hRuler->raise(); m_vRuler->raise(); } void KisView::slotLoadingFinished() { // Set the current image for real now everything is ready to go. setCurrentImage(document()->currentImage()); m_paletteManager->showWidget( "layerbox" ); m_canvas->show(); disconnect(document(), TQT_SIGNAL(loadingFinished()), TQT_TQOBJECT(this), TQT_SLOT(slotLoadingFinished())); m_imageLoaded = true; startInitialZoomTimerIfReady(); } void KisView::startInitialZoomTimerIfReady() { if (m_imageLoaded && m_showEventReceived && m_guiActivateEventReceived) { m_initialZoomTimer.start(250, true); } } void KisView::slotInitialZoomTimeout() { Q_ASSERT(!m_paintViewEnabled); m_paintViewEnabled = true; setInitialZoomLevel(); } void KisView::slotCreateMask() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; KNamedCommand *cmd = layer->createMaskCommand(); cmd->execute(); if (undoAdapter() && undoAdapter()->undo()) { undoAdapter()->addCommand(cmd); } } void KisView::slotMaskFromSelection() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; KNamedCommand *cmd = layer->maskFromSelectionCommand(); cmd->execute(); if (undoAdapter() && undoAdapter()->undo()) { undoAdapter()->addCommand(cmd); } } void KisView::slotMaskToSelection() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; KNamedCommand *cmd = layer->maskToSelectionCommand(); cmd->execute(); if (undoAdapter() && undoAdapter()->undo()) { undoAdapter()->addCommand(cmd); } } void KisView::slotApplyMask() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; KNamedCommand *cmd = layer->applyMaskCommand(); cmd->execute(); if (undoAdapter() && undoAdapter()->undo()) { undoAdapter()->addCommand(cmd); } } void KisView::slotRemoveMask() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; KNamedCommand *cmd = layer->removeMaskCommand(); cmd->execute(); if (undoAdapter() && undoAdapter()->undo()) { undoAdapter()->addCommand(cmd); } } void KisView::slotEditMask() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; layer->setEditMask(m_editMask->isChecked()); } void KisView::slotShowMask() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) return; layer->setRenderMask(m_showMask->isChecked()); } void KisView::maskUpdated() { KisPaintLayer* layer = dynamic_cast(currentImg()->activeLayer().data()); if (!layer) { m_createMask->setEnabled(false); m_applyMask->setEnabled(false); m_removeMask->setEnabled(false); m_editMask->setEnabled(false); m_showMask->setEnabled(false); return; } m_createMask->setEnabled(!layer->hasMask()); m_maskFromSelection->setEnabled(true); // Perhaps also update this to false when no selection? m_maskToSelection->setEnabled(layer->hasMask()); m_applyMask->setEnabled(layer->hasMask()); m_removeMask->setEnabled(layer->hasMask()); m_editMask->setEnabled(layer->hasMask()); m_editMask->setChecked(layer->editMask()); m_showMask->setEnabled(layer->hasMask()); m_showMask->setChecked(layer->renderMask()); } #include "kis_view.moc"