def exportDocument(self, document, directory): if document is not None: self.json = { "skeleton": { "images": directory }, "bones": [{ "name": "root" }], "slots": [], "skins": { "default": {} }, "animations": {} } self.spineBones = self.json['bones'] self.spineSlots = self.json['slots'] self.spineSkins = self.json['skins']['default'] Krita.instance().setBatchmode(True) self.document = document self._export(document.rootNode(), directory) Krita.instance().setBatchmode(False) with open('{0}/{1}'.format(directory, 'spine.json'), 'w') as outfile: json.dump(self.json, outfile, indent=2) else: self._alert("Please select a Document")
def exportDocument(self): document = Krita.instance().activeDocument() if document is not None: if not self.directory: self.directory = os.path.dirname(document.fileName()) if document.fileName() else os.path.expanduser("~") self.directory = QFileDialog.getExistingDirectory(None, "Select a folder", self.directory, QFileDialog.ShowDirsOnly) if not self.directory: self._alert('Abort!') return self.json = { "skeleton": {"images": self.directory}, "bones": [{"name": "root"}], "slots": [], "skins": {"default": {}}, "animations": {} } self.spineBones = self.json['bones'] self.spineSlots = self.json['slots'] self.spineDefaultSkin = self.json['skins']['default'] Krita.instance().setBatchmode(True) self.document = document self._export(document.rootNode(), self.directory) Krita.instance().setBatchmode(False) with open('{0}/{1}'.format(self.directory, 'spine.json'), 'w') as outfile: json.dump(self.json, outfile, indent=2) self._alert("Export Successful") else: self._alert("Please select a Document")
def _active_document(): """ Returns the current document. """ if not Krita.instance(): return None if not Krita.instance().documents(): return None return Krita.instance().activeDocument()
def __initialiseDoc(self): """Initialise temporary document""" self.__calculateBounds() # The __tmpDoc contain a flatened copy of current document self.__tmpDoc = Krita.instance().createDocument( self.__boundsSource.width(), self.__boundsSource.height(), "Jpeg Export - Temporary preview", self.__doc.colorModel(), self.__doc.colorDepth(), self.__doc.colorProfile(), self.__doc.resolution()) self.__tmpDocTgtNode = self.__tmpDoc.createNode( "Preview", "paintlayer") #self.__tmpDocTgtNode.setPixelData(self.__doc.pixelData(self.__boundsSource.x(), self.__boundsSource.y(), self.__boundsSource.width(), self.__boundsSource.height()), 0, 0, self.__boundsSource.width(), self.__boundsSource.height() ) self.__tmpDoc.rootNode().addChildNode(self.__tmpDocTgtNode, None) self.__tmpDoc.setBatchmode(True) # force jpeg export self.timerEvent(None) # The __tmpDocPreview contain the Jpeg file for preview self.__tmpDocPreview = Krita.instance().createDocument( self.__boundsSource.width(), self.__boundsSource.height(), "Jpeg Export - Temporary preview", self.__doc.colorModel(), self.__doc.colorDepth(), self.__doc.colorProfile(), self.__doc.resolution()) # add original document content, as reference for diff self.__tmpDocPreviewSrcNode = self.__tmpDocPreview.createNode( "Source", "paintlayer") #self.__tmpDocPreviewSrcNode.setPixelData(self.__doc.pixelData(self.__boundsSource.x(), self.__boundsSource.y(), self.__boundsSource.width(), self.__boundsSource.height()), 0, 0, self.__boundsSource.width(), self.__boundsSource.height() ) self.__tmpDocPreview.rootNode().addChildNode( self.__tmpDocPreviewSrcNode, None) # add file layer linked to exported jpeg document, to see preview self.__tmpDocPreviewFileNode = self.__tmpDocPreview.createFileLayer( "Preview", self.__tmpExportFile, "None") self.__tmpDocPreview.rootNode().addChildNode( self.__tmpDocPreviewFileNode, None) self.__tmpDocPreview.setBatchmode(True) self.__tmpDocPreview.setFileName(self.__tmpExportPreviewFile) Krita.instance().activeWindow().addView( self.__tmpDocPreview) # shows it in the application #self.lblDocDimension.setText(i18n(f"Dimensions: {self.__tmpDoc.width()}x{self.__tmpDoc.height()}")) scrollbars = EKritaWindow.scrollbars() if scrollbars: self.__viewScrollbarH, self.__viewScrollbarV = scrollbars self.__viewScrollbarH.sliderMoved.connect(self.__updatePosition) self.__viewScrollbarV.sliderMoved.connect(self.__updatePosition) self.__updatePosition() self.__updateDoc() self.__renderModeChanged()
def setup(self): """Is executed at Krita's startup""" @pyqtSlot() def windowCreated(): # the best place to initialise controller (just after main window is created) self.__initUiController(True) if not self.__isKritaVersionOk: return if checkKritaVersion(5, 0, 0): # windowCreated signal has been implemented with krita 5.0.0 Krita.instance().notifier().windowCreated.connect(windowCreated)
def __windowCreated(self): """Main window has been created""" def aboutToShowFileMenu(): self.__action.setEnabled( len(Krita.instance().activeWindow().views()) > 0) menuFile = None actionRef = None # search for menu 'File' menuFile = Krita.instance().activeWindow().qwindow().findChild( QMenu, 'file') if isinstance(menuFile, QMenu): # search for 'Export Advanced...' action actionRef = Krita.instance().action('file_export_advanced') if actionRef: # move action to right place menuFile.removeAction(self.__action) menuFile.insertAction(actionRef, self.__action) else: # not found?? # fallback actionRef = Krita.instance().action('file_export_file') getNext = False for action in menuFile.actions(): if action.objectName() == 'file_export_file': getNext = True elif getNext: actionRef = action break if actionRef: # move action to right place menuFile.removeAction(self.__action) menuFile.insertAction(actionRef, self.__action) else: qError( 'Unable to find <file_export_advanced> neither <file_export_file>!' ) # update icon self.__action.setIcon(QIcon(actionRef.icon())) # by default, set menu disabled self.__action.setEnabled(False) menuFile.aboutToShow.connect(aboutToShowFileMenu)
def __init__(self, parent=None): super(KBRotationSlider, self).__init__(0, 360, parent) self.view = Krita.instance().activeWindow().activeView() self.setAffixes('Canvas Rotation: ', '°') legacySupportedVersion = 428 currentVersion = int(Krita.instance().version().replace('.', '')[:3]) setRotation = None if currentVersion > legacySupportedVersion: setRotation = lambda: self.view.canvas().setRotation(self.value()) else: # prior to Krita 4.2.9 the API had a bug which made 'setRotation' function as 'rotateCanvas' setRotation = lambda: self.view.canvas().setRotation(self.value() - self.view.canvas().rotation()) self.connectValueChanged(setRotation)
def set_frame_range(self, in_frame=None, out_frame=None, **kwargs): """ set_frame_range will set the frame range using `in_frame` and `out_frame` :param int in_frame: in_frame for the current context (e.g. the current shot, current asset etc) :param int out_frame: out_frame for the current context (e.g. the current shot, current asset etc) """ krita_app = Krita.instance() active_doc = Krita.instance().activeDocument() if active_doc: active_doc.setFullClipRangeStartTime(int(in_frame)) active_doc.setFullClipRangeEndTime(int(out_frame))
def create_sgtk_disabled_menu(menu_name): """ Render a special "shotgun is disabled" menu """ win = Krita.instance().window().qwindow() # Find the shotgun menu menuBar = win.menuBar() sg_menu = None for action in menuBar.actions(): if action.objectName == "shotgun": sg_menu = action.menu() break if sg_menu: # Clear all the actions before adding our item sg_menu.clear() else: # we need to create a new shotgun menu sg_menu = QtGui.QMenu("Shotgun", menuBar) sg_menu.setObjectName("shotgun") menu_action = menuBar.addMenu(sg_menu) menu_action.setObjectName("shotgun") # add the disabled action to our menu disabled_action = QtGui.QAction("Sgtk is disabled.") disabled_action.triggered.connect(sgtk_disabled_message) disabled_action.setObjectName("shotgun_disabled")
def initCanvasOptions(self, config, data): for entry in config: if config.getboolean(entry): self.canvasOptions.loadButton( data[entry], Krita.instance().action(data[entry]['id']).trigger )
def _import_animation_frames(self, path, sg_publish_data): krita_app = Krita.instance() doc = krita_app.activeDocument() if not doc: return False app = self.parent template = app.sgtk.template_from_path(path) fields = template.get_fields(path) images = app.sgtk.paths_from_template(template, fields, skip_keys=[SEQUENCE_FIELD]) # a quick way to get the images sorted by frame, as this matters when # we insert them in the layer frame_images = [] for image in images: fields = template.get_fields(image) frame = int(fields[SEQUENCE_FIELD]) bisect.insort(frame_images, (frame, image)) sorted_images = [frame_image[1] for frame_image in frame_images] # current time t = doc.currentTime() # insert from the current time onwards doc.importAnimation(sorted_images, t, 1) doc.waitForDone()
def __init__(self, parent): super(KBTitleBar, self).__init__(parent) self.parent = parent self.layout = QHBoxLayout() self.layout.setContentsMargins(2, 1, 2, 1) self.pressing = False self.title = QLabel("KanvasBuddy") font = self.font() font.setPixelSize(9) self.title.setFont(font) self.title.setStyleSheet(""" color: grey; """) self.btn_close = QToolButton() self.btn_close.setFixedSize(10, 10) self.btn_close.setIconSize(QSize(7,7)) self.btn_close.clicked.connect(self.parent.close) self.btn_close.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton)) self.btn_close.setFocusPolicy(Qt.NoFocus) self.btn_pinned_mode = QToolButton() self.btn_pinned_mode.setCheckable(True) self.btn_pinned_mode.setToolTip("Toggle pinned panel mode") self.btn_pinned_mode.setFixedSize(10, 10) self.btn_pinned_mode.setIconSize(QSize(7,7)) self.btn_pinned_mode.clicked.connect(self.parent.togglePinnedMode) self.btn_pinned_mode.setIcon(Krita.instance().icon('light_krita_tool_reference_images.svg')) self.btn_pinned_mode.setFocusPolicy(Qt.NoFocus) self.layout.addWidget(self.title) self.layout.addWidget(self.btn_pinned_mode) self.layout.addWidget(self.btn_close) self.setLayout(self.layout)
def _open_as_layer(self, path, sg_publish_data): krita_app = Krita.instance() doc = krita_app.activeDocument() if not doc: return False filename_file = os.path.basename(path) filename_filename, _ = os.path.splitext(filename_file) layer_name = filename_filename layer_node = doc.createNode(layer_name, "paintlayer") doc.rootNode().addChildNode(layer_node, None) # load as a different doc layer_doc = krita_app.openDocument(path) layer_doc.waitForDone() pixel_data = layer_doc.pixelData(0, 0, layer_doc.width(), layer_doc.height()) # paste pixel info layer_node.setPixelData(pixel_data, 0, 0, layer_doc.width(), layer_doc.height()) doc.waitForDone() doc.setActiveNode(layer_node) doc.refreshProjection() doc.waitForDone() # no need anymore layer_doc.close()
def execute(self, operation, file_path, **kwargs): """ Main hook entry point :operation: String Scene operation to perform :file_path: String File path to use if the operation requires it (e.g. open) :returns: Depends on operation: 'current_path' - Return the current scene file path as a String all others - None """ krita_app = Krita.instance() active_doc = krita_app.activeDocument() if operation == "current_path": current_project_filename = None if active_doc: current_project_filename = active_doc.fileName() return current_project_filename elif operation == "open": doc = krita_app.openDocument(file_path) krita_app.activeWindow().addView(doc) doc.waitForDone() elif operation == "save": if active_doc: active_doc.save() active_doc.waitForDone()
def setup(self): """ This is where most of the setup takes place! """ qDebug("Hello Setup") action = Krita.instance().createAction("hello_python", "hello") action.triggered.connect(hello)
def __init__(self, parent=None): super(KBPanelCloseButton, self).__init__(parent) self.setIcon(Krita.instance().action('move_layer_up').icon()) self.setIconSize(QSize(10, 10)) self.setFixedHeight(12) self.clicked.connect( lambda: self.parentWidget().parentWidget().setCurrentIndex(0))
def __init__(self, parent): """""" super().__init__(parent) self.kritaInstance = Krita.instance() self.actions = [] self.popupframe = None
def _session_document(): """ Return the current active document :return: """ krita_app = Krita.instance() active_doc = krita_app.activeDocument() return active_doc
def get_active_node(): """ common shorthand. """ app = Krita.instance() document = app.activeDocument() if document is not None: return document.activeNode()
def __init__(self, parent=None): super(KBFlowSlider, self).__init__(parent=parent) self.view = Krita.instance().activeWindow().activeView() self.setAffixes('Flow: ', '%') self.connectValueChanged( lambda: self.view.setPaintingFlow(self.value()/100) )
def write_settings(self): main_program = Krita.instance() setting = ';'.join([ self.color_to_settings(line.left) + '|' + self.color_to_settings(line.right) for line in self.sliders ]) main_program.writeSetting("", "MixerSliderColors", setting)
def get_frame_range(self, **kwargs): """ get_frame_range will return a tuple of (in_frame, out_frame) :returns: Returns the frame range in the form (in_frame, out_frame) :rtype: tuple[int, int] """ krita_app = Krita.instance() active_doc = Krita.instance().activeDocument() current_in = 0 current_out = 0 if active_doc: current_in = int(active_doc.fullClipRangeStartTime()) current_out = int(active_doc.fullClipRangeEndTime()) return (current_in, current_out)
def find_document_for(node): """ Missing method: document = krita.Node.document(self) """ app = Krita.instance() for document in app.documents(): for n, _ in walk_nodes([document.rootNode()]): if n == node: return document
def keep_active_document(new_document=None): app = Krita.instance() old_document = app.activeDocument() try: if new_document is not None: set_active_document(new_document) yield app.activeDocument() finally: if old_document is not None: set_active_document(old_document)
def keep_batch_mode(new_batch_mode=None): app = Krita.instance() old_batch_mode = app.batchMode() try: if new_batch_mode is not None: app.setBatchMode(new_batch_mode) yield app.batchMode() finally: if old_batch_mode is not None: app.setBatchMode(old_batch_mode)
def __initUiController(self, kritaIsStarting=False): """Initialise UI controller `kritaIsStarting` set to True if UiConbtroller is intialised during Krita's startup, otherwise set to False (initialised on first manual execution) """ @pyqtSlot('QString') def opened(document): # a document has been created: if filename is set, document has been opened if document.fileName() != '': self.__uiController.commandGoLastDocsOpenedAdd( document.fileName()) @pyqtSlot('QString') def saved(fileName): # a document has been saved if fileName != '': self.__uiController.commandGoLastDocsSavedAdd(fileName) try: Krita.instance().notifier().imageCreated.disconnect() except Exception as e: pass try: Krita.instance().notifier().imageSaved.disconnect() except Exception as e: pass try: Krita.instance().notifier().applicationClosing.disconnect() except Exception as e: pass if self.__uiController is None: # no controller, create it # (otherwise, with Krita 5.0.0, can be triggered more than once time - on each new window) Krita.instance().notifier().imageCreated.connect(opened) Krita.instance().notifier().imageSaved.connect(saved) self.__uiController = BCUIController(PLUGIN_MENU_ENTRY, PLUGIN_VERSION, kritaIsStarting)
def init_engine(self): """ Initializes the Krita engine. """ self.logger.debug("%s: Initializing...", self) self._kritaInstance = Krita.instance() # default menu name is Shotgun but this can be overriden # in the configuration to be Sgtk in case of conflicts self._menu_name = "Shotgun"
def sgtk_disabled_message(): """ Explain why sgtk is disabled. """ msg = ( "Shotgun integration is disabled because it cannot recognize " "the currently opened file. Try opening another file or restarting " "Krita.") win = Krita.instance().window().qwindow() QtGui.QMessageBox.information(win, "Sgtk is disabled.", msg)
def _batch_mode(state): """ A handy context for running things in Krita in batch mode """ krita_app = Krita.instance() current_state = krita_app.batchmode() krita_app.setBatchmode(state) try: yield finally: krita_app.setBatchmode(current_state)
def __init__(self, parent): # Default options # Always initialise the superclass. # This is necessary to create the underlying C++ object super(JpegExport, self).__init__(parent) self.parent = parent self.__uiController = None self.__isKritaVersionOk = checkKritaVersion(*REQUIRED_KRITA_VERSION) self.__dlgParentWidget = QWidget() self.__action = None self.__notifier = Krita.instance().notifier()