예제 #1
0
    def _rename_file(self):
        item = self.currentItem()
        if item.parent() is None:
            pathForFile = item.path
        else:
            pathForFile = os.path.join(item.path, item.text(0))
        result = QInputDialog.getText(self, self.tr("Rename File"),
            self.tr("Enter New File Name:"), text=item.text(0))
        fileName = result[0]

        if result[1] and fileName.strip() != '':
            fileName = os.path.join(
                file_manager.get_folder(pathForFile), fileName)
            if pathForFile == fileName:
                return
            try:
                fileName = file_manager.rename_file(pathForFile, fileName)
                name = file_manager.get_basename(fileName)
                main_container = IDE.get_service('main_container')
                if main_container and main_container.is_open(pathForFile):
                    main_container.change_open_tab_name(pathForFile, fileName)
                subitem = ProjectItem(item.parent(), name,
                    file_manager.get_folder(fileName))
                subitem.setToolTip(0, name)
                subitem.setIcon(0, self._get_file_icon(name))
                index = item.parent().indexOfChild(item)
                subitem.parent().takeChild(index)
            except file_manager.NinjaFileExistsException as ex:
                QMessageBox.information(self, self.tr("File Already Exists"),
                    (self.tr("Invalid Path: the file '%s' already exists.") %
                        ex.filename))
예제 #2
0
    def expand_tab_name(self, title):
        """Expand the tab title to differentiate files with the same name.

        The way it is currently implemented, it will only change the first
        conflicting title passed in, because it only searches until the new
        title isn't in the tab titles.
        """
        if title == 'New Document':
            return
        elif title not in self.titles:
            self.titles.append(title)
            return
        indexes = [i for i in range(self.count())
            if type(self.widget(i)) is editor.Editor and
            self.tabText(i) == title and
            self.widget(i).ID]  # self.widget.ID returns the basename
        self.dontLoopInExpandTitle = True
        for i in indexes:
            newName = file_manager.create_path(
                file_manager.get_basename(
                    file_manager.get_folder(self.widget(i).ID)), title)
            while newName in self.titles:
                # Keep prepending the folder name onto the title until it
                # does not conflict.
                path = self.widget(i).ID
                tempDir = path[:path.rfind(newName)]
                newName = file_manager.create_path(
                    file_manager.get_basename(
                        file_manager.get_folder(tempDir)),
                    '..',
                    title)
            self.titles.append(newName)
            self.setTabText(i, newName)
        self.dontLoopInExpandTitle = False
예제 #3
0
 def get_item_for_path(self, path):
     items = self.findItems(file_manager.get_basename(path),
         Qt.MatchRecursive, 0)
     folder = file_manager.get_folder(path)
     for item in items:
         if file_manager.belongs_to_folder(folder, item.path):
             return item
예제 #4
0
    def open_file(self, filename='', cursorPosition=-1,
                  tabIndex=None, positionIsLineNumber=False, notStart=True):
        if not filename:
            if settings.WORKSPACE:
                directory = settings.WORKSPACE
            else:
                directory = os.path.expanduser("~")
                editorWidget = self.get_current_editor()
                ninjaide = IDE.get_service('ide')
                if ninjaide:
                    current_project = ninjaide.get_current_project()
                    if current_project is not None:
                        directory = current_project
                    elif editorWidget is not None and editorWidget.ID:
                        directory = file_manager.get_folder(editorWidget.ID)
            extensions = ';;'.join(
                ['(*%s)' % e for e in
                    settings.SUPPORTED_EXTENSIONS + ['.*', '']])
            fileNames = list(QFileDialog.getOpenFileNames(self,
                self.tr("Open File"), directory, extensions))
        else:
            fileNames = [filename]
        if not fileNames:
            return

        for filename in fileNames:
            if file_manager.get_file_extension(filename) in ('jpg', 'png'):
                self.open_image(filename)
            elif file_manager.get_file_extension(filename).endswith('ui'):
                self.w = uic.loadUi(filename)
                self.w.show()
            else:
                self.__open_file(filename, cursorPosition,
                    tabIndex, positionIsLineNumber)
예제 #5
0
 def _rename_file(self):
     path = self.model().filePath(self.currentIndex())
     name = file_manager.get_basename(path)
     new_name, ok = QInputDialog.getText(
         self, translations.TR_RENAME_FILE,
         translations.TR_ENTER_NEW_FILENAME,
         text=name)
     if ok and new_name.strip():
         filename = file_manager.create_path(
             file_manager.get_folder(path), new_name)
         if path == filename:
             return
         ninjaide = IDE.get_service("ide")
         print(ninjaide.filesystem.get_files())
         current_nfile = ninjaide.get_or_create_nfile(path)
         editable = ninjaide.get_editable(nfile=current_nfile)
         current_nfile.move(filename)
         if editable is not None:
             main_container = IDE.get_service("main_container")
             main_container.combo_area.bar.update_item_text(
                 editable, new_name)
             tree = ninjaide.filesystem.get_files()
             # FIXME: this is bad
             tree[filename] = tree.pop(path)
         print(ninjaide.filesystem.get_files())
예제 #6
0
 def __main_execution(self):
     self.__elapsed.start()
     self.__current_process = self.main_process
     if not self.only_text:
         # In case a text is executed and not a file or project
         file_directory = file_manager.get_folder(self.filename)
         self.main_process.setWorkingDirectory(file_directory)
     self.main_process.setProgram(self.python_exec)
     self.main_process.setArguments(self.arguments)
     environment = QProcessEnvironment()
     system_environment = self.main_process.systemEnvironment()
     for env in system_environment:
         key, value = env.split("=", 1)
         environment.insert(key, value)
     self.main_process.setProcessEnvironment(environment)
     self.main_process.start()
예제 #7
0
    def _rename_file(self):
        path = self.model().filePath(self.currentIndex())
        name = file_manager.get_basename(path)
        result = QInputDialog.getText(self, self.tr("Rename File"),
            self.tr("Enter New File Name:"), text=name)
        fileName = result[0]

        if result[1] and fileName.strip() != '':
            fileName = os.path.join(
                file_manager.get_folder(path), fileName)
            if path == fileName:
                return
            ide_srv = IDE.get_service("ide")
            current_nfile = ide_srv.get_or_create_nfile(path)
            #FIXME: Catch willOverWrite and willMove signals
            current_nfile.move(fileName)
    def _rename_file(self):
        path = self.model().filePath(self.currentIndex())
        name = file_manager.get_basename(path)
        result = QInputDialog.getText(self,
                                      translations.TR_RENAME_FILE,
                                      translations.TR_ENTER_NEW_FILENAME,
                                      text=name)
        fileName = result[0]

        if result[1] and fileName.strip() != '':
            fileName = os.path.join(file_manager.get_folder(path), fileName)
            if path == fileName:
                return
            ide_srv = IDE.get_service("ide")
            current_nfile = ide_srv.get_or_create_nfile(path)
            #FIXME: Catch willOverWrite and willMove signals
            current_nfile.move(fileName)
예제 #9
0
 def add_existing_file(self, path):
     relative = file_manager.convert_to_relative(self._actualProject.path,
                                                 path)
     paths = relative.split(os.sep)[:-1]
     itemParent = self._actualProject
     for p in paths:
         for i in range(itemParent.childCount()):
             item = itemParent.child(i)
             if item.text(0) == p:
                 itemParent = item
                 break
     itemParent.setSelected(True)
     name = file_manager.get_basename(path)
     subitem = ProjectItem(itemParent, name, file_manager.get_folder(path))
     subitem.setToolTip(0, name)
     subitem.setIcon(0, self._get_file_icon(name))
     itemParent.setExpanded(True)
예제 #10
0
    def open_file(self,
                  filename='',
                  cursorPosition=-1,
                  tabIndex=None,
                  positionIsLineNumber=False,
                  notStart=True):
        logger.debug("will try to open %s" % filename)
        if not filename:
            logger.debug("has nofilename")
            if settings.WORKSPACE:
                directory = settings.WORKSPACE
            else:
                directory = os.path.expanduser("~")
                editorWidget = self.get_current_editor()
                ninjaide = IDE.get_service('ide')
                if ninjaide:
                    current_project = ninjaide.get_current_project()
                    if current_project is not None:
                        directory = current_project
                    elif editorWidget is not None and editorWidget.ID:
                        directory = file_manager.get_folder(editorWidget.ID)
            extensions = ';;'.join([
                '(*%s)' % e
                for e in settings.SUPPORTED_EXTENSIONS + ['.*', '']
            ])
            fileNames = list(
                QFileDialog.getOpenFileNames(self, self.tr("Open File"),
                                             directory, extensions))
        else:
            logger.debug("has filename")
            fileNames = [filename]
        if not fileNames:
            return

        for filename in fileNames:
            if file_manager.get_file_extension(filename) in ('jpg', 'png'):
                logger.debug("will open as image")
                self.open_image(filename)
            elif file_manager.get_file_extension(filename).endswith('ui'):
                logger.debug("will load in ui editor")
                self.w = uic.loadUi(filename)
                self.w.show()
            else:
                logger.debug("will try to open")
                self.__open_file(filename, cursorPosition, tabIndex,
                                 positionIsLineNumber)
예제 #11
0
 def add_existing_file(self, path):
     relative = file_manager.convert_to_relative(
         self._actualProject.path, path)
     paths = relative.split(os.sep)[:-1]
     itemParent = self._actualProject
     for p in paths:
         for i in range(itemParent.childCount()):
             item = itemParent.child(i)
             if item.text(0) == p:
                 itemParent = item
                 break
     itemParent.setSelected(True)
     name = file_manager.get_basename(path)
     subitem = ProjectItem(itemParent, name, file_manager.get_folder(path))
     subitem.setToolTip(0, name)
     subitem.setIcon(0, self._get_file_icon(name))
     itemParent.setExpanded(True)
예제 #12
0
 def open_project_folder(self, folderName='', notIDEStart=True):
     """Open a Project and load the symbols in the Code Locator."""
     if not self.tree_projects and notIDEStart:
         QMessageBox.information(
             self, self.tr("Projects Disabled"),
             self.tr("Project support has been disabled from Preferences"))
         return
     if not folderName:
         if settings.WORKSPACE:
             directory = settings.WORKSPACE
         else:
             directory = os.path.expanduser("~")
             current_project = self.get_actual_project()
             main_container = IDE.get_service('main_container')
             if main_container:
                 editorWidget = main_container.get_actual_editor()
                 if current_project is not None:
                     directory = current_project
                 elif editorWidget is not None and editorWidget.ID:
                     directory = file_manager.get_folder(editorWidget.ID)
         folderName = QFileDialog.getExistingDirectory(
             self, self.tr("Open Project Directory"), directory)
     try:
         if not folderName:
             return
         if not self.tree_projects.is_open(folderName):
             self.tree_projects.mute_signals = True
             self.tree_projects.loading_project(folderName)
             thread = ui_tools.ThreadProjectExplore()
             self._thread_execution[folderName] = thread
             self.connect(thread,
                          SIGNAL("folderDataAcquired(PyQt_PyObject)"),
                          self._callback_open_project)
             self.connect(thread, SIGNAL("finished()"),
                          self._unmute_tree_signals_clean_threads)
             thread.open_folder(folderName)
         else:
             self.tree_projects._set_current_project(folderName)
     except Exception as reason:
         logger.error('open_project_folder: %s', reason)
         if not notIDEStart:
             QMessageBox.information(
                 self, self.tr("Incorrect Project"),
                 self.tr("The project could not be loaded!"))
예제 #13
0
    def open_file(self, filename='', line=-1, col=0, ignore_checkers=False):
        logger.debug("will try to open %s" % filename)
        if not filename:
            logger.debug("has nofilename")
            if settings.WORKSPACE:
                directory = settings.WORKSPACE
            else:
                directory = os.path.expanduser("~")
                editorWidget = self.get_current_editor()
                ninjaide = IDE.get_service('ide')
                if ninjaide:
                    current_project = ninjaide.get_current_project()
                    if current_project is not None:
                        directory = current_project
                    elif editorWidget is not None and editorWidget.file_path:
                        directory = file_manager.get_folder(
                            editorWidget.file_path)
            extensions = ';;'.join(
                ['{}(*{})'.format(e.upper()[1:], e)
                 for e in settings.SUPPORTED_EXTENSIONS + ['.*', '']])
            fileNames = QFileDialog.getOpenFileNames(self,
                                                     self.tr("Open File"),
                                                     directory,
                                                     extensions)[0]
        else:
            logger.debug("has filename")
            fileNames = [filename]
        if not fileNames:
            return

        for filename in fileNames:
            image_extensions = ('bmp', 'gif', 'jpeg', 'jpg', 'png')
            if file_manager.get_file_extension(filename) in image_extensions:
                logger.debug("will open as image")
                self.open_image(filename)
            elif file_manager.get_file_extension(filename).endswith('ui'):
                logger.debug("will load in ui editor")
                self.w = uic.loadUi(filename)
                self.w.show()
            else:
                logger.debug("will try to open: " + filename)
                self.__open_file(filename, line, col,
                                 ignore_checkers)
예제 #14
0
 def open_project_folder(self, folderName='', notIDEStart=True):
     """Open a Project and load the symbols in the Code Locator."""
     if not self.tree_projects and notIDEStart:
         QMessageBox.information(self, self.tr("Projects Disabled"),
             self.tr("Project support has been disabled from Preferences"))
         return
     if not folderName:
         if settings.WORKSPACE:
             directory = settings.WORKSPACE
         else:
             directory = os.path.expanduser("~")
             current_project = self.get_actual_project()
             main_container = IDE.get_service('main_container')
             if main_container:
                 editorWidget = main_container.get_actual_editor()
                 if current_project is not None:
                     directory = current_project
                 elif editorWidget is not None and editorWidget.ID:
                     directory = file_manager.get_folder(editorWidget.ID)
         folderName = QFileDialog.getExistingDirectory(self,
             self.tr("Open Project Directory"), directory)
     try:
         if not folderName:
             return
         if not self.tree_projects.is_open(folderName):
             self.tree_projects.mute_signals = True
             self.tree_projects.loading_project(folderName)
             thread = ui_tools.ThreadProjectExplore()
             self._thread_execution[folderName] = thread
             self.connect(thread,
                 SIGNAL("folderDataAcquired(PyQt_PyObject)"),
                 self._callback_open_project)
             self.connect(thread,
                 SIGNAL("finished()"),
                 self._unmute_tree_signals_clean_threads)
             thread.open_folder(folderName)
         else:
             self.tree_projects._set_current_project(folderName)
     except Exception as reason:
         logger.error('open_project_folder: %s', reason)
         if not notIDEStart:
             QMessageBox.information(self, self.tr("Incorrect Project"),
                 self.tr("The project could not be loaded!"))
예제 #15
0
    def open_file(self, filename='', line=-1, col=0, ignore_checkers=False):
        logger.debug("will try to open %s" % filename)
        if not filename:
            logger.debug("has nofilename")
            if settings.WORKSPACE:
                directory = settings.WORKSPACE
            else:
                directory = os.path.expanduser("~")
                editorWidget = self.get_current_editor()
                ninjaide = IDE.get_service('ide')
                if ninjaide:
                    current_project = ninjaide.get_current_project()
                    if current_project is not None:
                        directory = current_project
                    elif editorWidget is not None and editorWidget.file_path:
                        directory = file_manager.get_folder(
                            editorWidget.file_path)
            extensions = ';;'.join(
                ['{}(*{})'.format(e.upper()[1:], e)
                 for e in settings.SUPPORTED_EXTENSIONS + ['.*', '']])
            fileNames = QFileDialog.getOpenFileNames(self,
                                                     self.tr("Open File"),
                                                     directory,
                                                     extensions)[0]
        else:
            logger.debug("has filename")
            fileNames = [filename]
        if not fileNames:
            return

        for filename in fileNames:
            image_extensions = ('bmp', 'gif', 'jpeg', 'jpg', 'png')
            if file_manager.get_file_extension(filename) in image_extensions:
                logger.debug("will open as image")
                self.open_image(filename)
            elif file_manager.get_file_extension(filename).endswith('ui'):
                logger.debug("will load in ui editor")
                self.w = uic.loadUi(filename)
                self.w.show()
            else:
                logger.debug("will try to open: " + filename)
                self.__open_file(filename, line, col,
                                 ignore_checkers)
예제 #16
0
 def __main_execution(self):
     self._current_process = self._process
     file_directory = file_manager.get_folder(self._filename)
     self._process.setWorkingDirectory(file_directory)
     # Force python to unbuffer stding ad stdout
     options = ['-u'] + settings.EXECUTION_OPTIONS.split()
     # Set python exec and arguments
     program_params = [
         param.strip() for param in self._params.split(',') if param
     ]
     self._process.setProgram(self.python_exec)
     self._process.setArguments(options + [self._filename] + program_params)
     environment = QProcessEnvironment()
     system_environemnt = self._process.systemEnvironment()
     for env in system_environemnt:
         key, value = env.split('=', 1)
         environment.insert(key, value)
     self._process.setProcessEnvironment(environment)
     # Start!
     self._process.start()
예제 #17
0
    def __main_execution(self):
        """Execute the project."""
        self.output.setCurrentCharFormat(self.output.plain_format)
        message = ''
        if self.__preScriptExecuted:
            self.__preScriptExecuted = False
            message = self.tr(
                "Pre Execution Script Successfully executed.\n\n")
        self.output.setPlainText(message + 'Running: %s (%s)\n\n' %
                                 (self.fileName, time.ctime()))
        self.output.moveCursor(QTextCursor.Down)
        self.output.moveCursor(QTextCursor.Down)
        self.output.moveCursor(QTextCursor.Down)

        if not self.pythonExec:
            self.pythonExec = settings.PYTHON_EXEC
        #change the working directory to the fileName dir
        file_directory = file_manager.get_folder(self.fileName)
        self._proc.setWorkingDirectory(file_directory)
        #force python to unbuffer stdin and stdout
        options = ['-u'] + settings.EXECUTION_OPTIONS.split()
        self.currentProcess = self._proc

        env = QProcessEnvironment()
        system_environemnt = self._proc.systemEnvironment()
        for e in system_environemnt:
            key, value = e.split('=', 1)
            env.insert(key, value)
        if self.PYTHONPATH:
            envpaths = [path for path in self.PYTHONPATH.splitlines()]
            for path in envpaths:
                env.insert('PYTHONPATH', path)
        env.insert('PYTHONIOENCODING', 'utf-8')
        env.insert('PYTHONPATH', ':'.join(sys.path))
        self._proc.setProcessEnvironment(env)

        self._proc.start(self.pythonExec, options + [self.fileName] +
                         [p.strip()
                          for p in self.programParams.split(',') if p])
예제 #18
0
    def open_file(
        self, filename="", cursorPosition=-1, tabIndex=None, positionIsLineNumber=False, ignore_checkers=False
    ):
        logger.debug("will try to open %s" % filename)
        if not filename:
            logger.debug("has nofilename")
            if settings.WORKSPACE:
                directory = settings.WORKSPACE
            else:
                directory = os.path.expanduser("~")
                editorWidget = self.get_current_editor()
                ninjaide = IDE.get_service("ide")
                if ninjaide:
                    current_project = ninjaide.get_current_project()
                    if current_project is not None:
                        directory = current_project
                    elif editorWidget is not None and editorWidget.file_path:
                        directory = file_manager.get_folder(editorWidget.file_path)
            extensions = ";;".join(
                ["{}(*{})".format(e.upper()[1:], e) for e in settings.SUPPORTED_EXTENSIONS + [".*", ""]]
            )
            fileNames = list(QFileDialog.getOpenFileNames(self, self.tr("Open File"), directory, extensions))
        else:
            logger.debug("has filename")
            fileNames = [filename]
        if not fileNames:
            return

        for filename in fileNames:
            if file_manager.get_file_extension(filename) in ("jpg", "png"):
                logger.debug("will open as image")
                self.open_image(filename)
            elif file_manager.get_file_extension(filename).endswith("ui"):
                logger.debug("will load in ui editor")
                self.w = uic.loadUi(filename)
                self.w.show()
            else:
                logger.debug("will try to open")
                self.__open_file(filename, cursorPosition, tabIndex, positionIsLineNumber, ignore_checkers)
예제 #19
0
    def _rename_file(self):
        path = self.model().filePath(self.currentIndex())
        name = file_manager.get_basename(path)
        result = QInputDialog.getText(self, self.tr("Rename File"),
            self.tr("Enter New File Name:"), text=name)
        fileName = result[0]

        if result[1] and fileName.strip() != '':
            fileName = os.path.join(
                file_manager.get_folder(path), fileName)
            if path == fileName:
                return
            try:
                fileName = file_manager.rename_file(path, fileName)
                name = file_manager.get_basename(fileName)
                main_container = IDE.get_service('main_container')
                if main_container and main_container.is_open(path):
                    main_container.change_open_tab_name(path, fileName)
            except file_manager.NinjaFileExistsException as ex:
                QMessageBox.information(self, self.tr("File Already Exists"),
                    (self.tr("Invalid Path: the file '%s' already exists.") %
                        ex.filename))
예제 #20
0
 def open_file(self, filename='', line=-1, col=0, ignore_checkers=False):
     logger.debug("Will try to open %s" % filename)
     if not filename:
         logger.debug("Has no filename")
         if settings.WORKSPACE:
             directory = settings.WORKSPACE
         else:
             directory = os.path.expanduser("~")
             editor_widget = self.get_current_editor()
             ninjaide = IDE.get_service("ide")
             current_project = ninjaide.get_current_project()
             # TODO: handle current project in NProject
             if current_project is not None:
                 directory = current_project.full_path
             elif editor_widget is not None and editor_widget.file_path:
                 directory = file_manager.get_folder(
                     editor_widget.file_path)
         filenames = QFileDialog.getOpenFileNames(
             self,
             translations.TR_OPEN_A_FILE,
             directory,
             settings.get_supported_extensions_filter(),
             initialFilter="Python files (*.py *.pyw)")[0]
     else:
         logger.debug("Has filename")
         filenames = [filename]
     if not filenames:
         return
     for filename in filenames:
         image_extensions = ("png", "jpg", "jpeg", "bmp", "gif")
         if file_manager.get_file_extension(filename) in image_extensions:
             logger.debug("Will open as image")
             self.open_image(filename)
         else:
             logger.debug("Will try to open: %s" % filename)
             self.__open_file(filename,
                              line,
                              col,
                              ignore_checkers=ignore_checkers)
예제 #21
0
 def open_file(self, filename='', line=-1, col=0, ignore_checkers=False):
     if not filename:
         logger.debug("Has no filename")
         if settings.WORKSPACE:
             directory = settings.WORKSPACE
         else:
             directory = os.path.expanduser("~")
             editor_widget = self.get_current_editor()
             ninjaide = IDE.get_service("ide")
             current_project = ninjaide.get_current_project()
             # TODO: handle current project in NProject
             if current_project is not None:
                 directory = current_project.full_path
             elif editor_widget is not None and editor_widget.file_path:
                 directory = file_manager.get_folder(
                     editor_widget.file_path)
         filenames = QFileDialog.getOpenFileNames(
             self,
             translations.TR_OPEN_A_FILE,
             directory,
             settings.get_supported_extensions_filter(),
             initialFilter="Python files (*.py *.pyw)"
         )[0]
     else:
         logger.debug("Has filename")
         filenames = [filename]
     if not filenames:
         return
     for filename in filenames:
         image_extensions = ("png", "jpg", "jpeg", "bmp", "gif")
         if file_manager.get_file_extension(filename) in image_extensions:
             logger.debug("Will open as image")
             self.open_image(filename)
         else:
             logger.debug("Will try to open: %s" % filename)
             self.__open_file(
                 filename, line, col, ignore_checkers=ignore_checkers)