class NoGuiAnalysis(): def __init__(self,controller=None,mainWindow=None): ## input variables if controller == None: self.controller = Controller() else: self.controller = controller self.mainWindow = mainWindow self.validLanguages = ['r','python'] self.sphinxLog = None self.goFlag = False self.reload_program_paths() def reload_program_paths(self): """ function to update the paths to programs for system calls """ ## ensure that the log file is loaded if len(self.controller.log.log.items()) < 1: self.controller.log = Logger() self.rPath = self.controller.get_r_path(mainWindow=self.mainWindow) self.pythonPath = self.controller.get_python_path(mainWindow=self.mainWindow) self.sphinxPath = self.controller.get_sphinx_path(mainWindow=self.mainWindow) self.latexPath = self.controller.get_latex_path() self.parsePath = os.path.join(self.controller.baseDir,"ParseEmbedded.py") self.latex2htmlPath = self.controller.get_latex2html_path() def build(self,fileName=None,verbose=False): """ generic command to build a rst,nw or rnw document """ ## variables self.goFlag = False if self.mainWindow != None: self.mainWindow.ensure_tab_is_current() ## if a fileName is specified the set the current index if fileName != None and fileName in self.controller.fileNameList: currentIdx = self.controller.fileNameList.index(fileName) self.controller.currentFileIndex = currentIdx currentIdx = self.controller.currentFileIndex fileName = self.controller.fileNameList[currentIdx] filePath = self.controller.filePathList[currentIdx] fileLanguage = self.controller.fileLangList[currentIdx] self.reload_program_paths() goFlag = None if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] editor.clear_messages() self.output_text("BUILDING... %s"%fileName) ## error checking isClean = self.controller.sanitize_check(filePath) if isClean == False: msg = "Invalid file/dir name\n" msg += "%s\nremove characters like '$','#' and '&' then try again"%(filePath) self.display_error(msg) return isActive = self.is_active_project(filePath) if not isActive: return isTemplate = self.is_template() if isTemplate == True: return fileLanguage = fileLanguage.lower() if fileLanguage not in self.validLanguages: msg = "Valid languages are %s not %s"%(self.validLanguages,fileLanguage) self.display_error(msg) return ## save file if self.mainWindow != None: self.mainWindow.file_save(display=False) ## run the appropriate builder if re.search("\.rst",fileName,flags=re.IGNORECASE): self.build_rst(verbose=verbose) elif re.search("\.rnw|\.nw",fileName,flags=re.IGNORECASE): self.build_nw(verbose=verbose) else: msg = "Invalid file name extension\n" msg +="...lpEdit cannot build\n" msg +=filePath self.display_error(msg) def load_file(self,filePath,fileLang=None): ''' use the controller to load a specified file ''' filePath = os.path.realpath(filePath) if not os.path.exists(filePath): print("ERROR: invalid file path specified for load") print("... %s"%filePath) return isValid = self.controller.load_file(filePath,fileLang=fileLang) if isValid == False: print "ERROR: controller could not load specified file" print "\t", filePath def clean_file(self,filePath,verbose=False): ''' cleans a directory of its files -- function used with unittests ''' self.controller.clean_file(filePath) def output_text(self,txt): currentIdx = self.controller.currentFileIndex if self.mainWindow != None: if self.mainWindow.controller.editorList[currentIdx].textScreen.showMessages == False: self.mainWindow.controller.editorList[currentIdx].textScreen.toggle_message_btn() self.mainWindow.controller.editorList[currentIdx].textScreen.add_text(txt) else: print txt def copy_included_files(self,filePath,dirPath): """ Copy files that are included with the keyword INCLUDE The source file path is given and it is scanned for INCLUDE Each include may be multiple file paths (comma delim) """ baseDir = os.path.split(filePath)[0] ## adjust for subdirectories if os.path.split(baseDir)[1] != os.path.split(os.path.split(dirPath)[0])[1]: subdir = os.path.split(baseDir)[1] targetDir = os.path.join(dirPath,subdir) else: targetDir = dirPath subdir = None fid = open(filePath,'r') includedFiles = [] found = False for linja in fid: if re.search("^%|^\.\. ",linja) and re.search("INCLUDE",linja): linja = re.sub("INCLUDE[\W|\w]","",linja) linja = re.sub("\%|\s+|^\.\.","",linja) found = True linja = re.split(",",linja) for includedFile in linja: if os.path.exists(includedFile): includedFiles.append(os.path.realpath(includedFile)) else: includedFilePath = os.path.join(baseDir,includedFile) includedFiles.append(os.path.realpath(includedFilePath)) for includedFilePath in includedFiles: includedFilePath = includedFilePath includedFileName = os.path.split(includedFilePath)[-1] includedFileDir = os.path.split(includedFilePath)[-1] newFilePath = os.path.join(targetDir,includedFileName) if not os.path.exists(includedFilePath): msg = "Invalid INCLUDE path...\n" msg += includedFilePath if self.mainWindow != None: self.mainWindow.display_warning(msg) else: print msg return False if os.path.islink(newFilePath): os.remove(newFilePath) if os.path.exists(newFilePath): os.remove(newFilePath) self.output_text("INCLUDE: %s \n...%s"%(includedFilePath,newFilePath)) os.symlink(includedFilePath,newFilePath) return True def is_active_project(self,currentFilePath): """ check for an active project """ if currentFilePath == '' or currentFilePath == None: msg = "Load or create a new file before compiling code" self.display_error(msg) return False return True def is_template(self): """ checks to see if currentFile is a template or not """ templatesDir = self.controller.get_templates_dir() currentFilePath = self.controller.filePathList[self.controller.currentFileIndex] currentFileName = self.controller.fileNameList[self.controller.currentFileIndex] if os.path.join(templatesDir,currentFileName) == currentFilePath: msg = "Use 'Save As' before trying to work with template" self.display_error(msg) return True return False def display_error(self,msg): """ generic function to display an error """ if self.mainWindow != None: self.mainWindow.display_warning(re.sub("\n","<p>",msg)) else: print "ERROR: ", msg def build_nw(self,verbose=True): """ uses system calls to compile nw or sweave code """ ## variables templatesDir = self.controller.get_templates_dir() currentIdx = self.controller.currentFileIndex filePath = self.controller.filePathList[currentIdx] fileName = self.controller.fileNameList[currentIdx] fileLanguage = self.controller.fileLangList[currentIdx] fileLanguage = fileLanguage.lower() filePathBase = os.path.split(filePath)[0] texFileName = re.sub("\.rnw|\.nw|\.rst",".tex",fileName,flags=re.IGNORECASE) dirPath = self.controller.ensure_dir_present(filePath) assemblePath = os.path.join(self.controller.baseDir,"AssembleOutNW.py") ## ensure we are using the correct builder if not re.search("\.nw|\.rnw",fileName,flags=re.IGNORECASE): msg = "NoGuiAnalysis: Incorrect builder -- skipping" self.display_error(msg) return ## ensure the correct builder is being used (based on extension) if re.search("\.rnw",fileName,flags=re.IGNORECASE) and fileLanguage != 'r': msg = "Sweave styled documents cannot contain code\n" msg += "other than R. \nSave the document as a *.nw file and try again" self.display_error(msg) return elif re.search("\.rnw",fileName,flags=re.IGNORECASE): builder = 'sweave' else: builder = 'nw' ## copy target file to dir targetFilePath = os.path.join(dirPath,fileName) shutil.copy(filePath,targetFilePath) ## copy included files goFlag = self.copy_included_files(filePath,dirPath) if goFlag == False: errMsg = "Build aborted" self.display_error(errMsg) return False ## move a copy of each sty file into the dir styfilesDir = self.controller.get_styfiles_dir() for styfile in os.listdir(styfilesDir): if not re.search("\.sty",styfile): continue if os.path.exists(os.path.join(dirPath,styfile)) == False: shutil.copy(os.path.join(styfilesDir,styfile),os.path.join(dirPath,styfile)) ## paths if fileLanguage == 'python': chunksFilePath = os.path.join(dirPath,"chunks.py") outFilePath = os.path.join(dirPath,"outPy.txt") langCmd = self.pythonPath elif fileLanguage == 'r': chunksFilePath = os.path.join(dirPath,"chunks.R") outFilePath = os.path.join(dirPath,"outR.txt") langCmd = self.rPath+'script' ## remove old versions of the files for fname in [chunksFilePath,outFilePath,os.path.join(dirPath,texFileName)]: if os.path.exists(fname): os.remove(fname) if builder == 'sweave': self.output_text('BUILDING WITH SWEAVE...') compileCmd = '"%s" CMD Sweave "%s"'%(self.rPath,targetFilePath) self.run_subprocess(compileCmd) ## move the output to build directory tmpTex = os.path.join(os.getcwd(),texFileName) if os.path.exists(tmpTex): shutil.move(tmpTex,os.path.join(dirPath,texFileName)) elif builder == 'nw': ## extract the code self.output_text("EXTRACTING CODE...") compileCmd = '"%s" "%s" -i "%s" -o "%s"'%(self.pythonPath,self.parsePath, targetFilePath,chunksFilePath) self.run_subprocess(compileCmd) ## run extracted code if os.path.exists(chunksFilePath): self.output_text("RUNNING CODE...") compileCmd = '"%s" "%s" > "%s"'%(langCmd,chunksFilePath,outFilePath) self.run_subprocess(compileCmd) else: self.output_text("EXITING EARLY... could not find extracted code") return False if self.mainWindow != None: self.mainWindow.transitions.update_ui() ## exit early on error goFlag = self.check_standard_error(self.stdErr) if goFlag == False: self.output_text("EXITING EARLY... ERROR found in embedded code") return False ## reassemble the *.tex file with code results if os.path.exists(outFilePath): self.output_text("REASSEMBLING CODE AND RESULTS...") compileCmd = '"%s" "%s" -i "%s" -o "%s" -l "%s"'%(self.pythonPath,assemblePath, targetFilePath,outFilePath,fileLanguage) self.run_subprocess(compileCmd) else: self.output_text("EXITING EARLY... there was a problem running the embedded code") return False ## check that we have a valid build self.goFlag = self.ensure_valid_build(os.path.join(dirPath,texFileName)) def check_standard_error(self,stdErr): """ a function that halts on certain standard error messages """ if stdErr != None and re.search('Traceback|Error:|Exception occurred:',stdErr,flags=re.IGNORECASE): return False else: return True def build_rst(self,verbose=True): """ uses system calls to compile a sphinx project """ ## variables currentIdx = self.controller.currentFileIndex filePath = self.controller.filePathList[currentIdx] filePathBase = os.path.split(filePath)[0] fileName = self.controller.fileNameList[currentIdx] fileLanguage = self.controller.fileLangList[currentIdx] fileLanguage = fileLanguage.lower() filePathBase = os.path.split(filePath)[0] assemblePath = os.path.join(self.controller.baseDir,"AssembleOutRst.py") tmpFilePath = filePath + ".tmp" ## ensure we are using the correct builder if not re.search("\.rst",fileName,flags=re.IGNORECASE): msg = "NoGuiAnalysis: Incorrect builder -- skipping" self.display_error(msg) return ## copy included files dirPath = self.controller.ensure_dir_present(filePath) goFlag = self.copy_included_files(filePath,dirPath) if goFlag == False: errMsg = "Build aborted" self.display_error(errMsg) return ## move a copy of each sty file into the dir styfilesDir = self.controller.get_styfiles_dir() for styfile in os.listdir(styfilesDir): if not re.search("\.sty",styfile): continue if os.path.exists(os.path.join(dirPath,styfile)) == False: shutil.copy(os.path.join(styfilesDir,styfile),os.path.join(dirPath,styfile)) ## initialize a sphinx project self.controller.initialize_sphinx_project(filePath) self.controller.copy_sphinx_files() self.sphinxLog = SphinxLogger(os.path.join(dirPath,'sphinx.log')) self.sphinxLog.write() ## ensure the current file is copied fileBase = os.path.split(filePath)[0] if fileBase != self.controller.sphinxProjectBase: subdirName = os.path.basename(os.path.dirname(filePath)) targetFilePath = os.path.join(dirPath,subdirName,fileName) else: targetFilePath = os.path.join(dirPath,fileName) print 'copying...', targetFilePath shutil.copy(filePath,targetFilePath) ## compile if fileLanguage == 'python': chunksFilePath = os.path.join(dirPath,"chunks.py") outFilePath = os.path.join(dirPath,"outPy.txt") langCmd = self.pythonPath elif fileLanguage == 'r': chunksFilePath = os.path.join(dirPath,"chunks.R") outFilePath = os.path.join(dirPath,"outR.txt") langCmd = self.rPath+'script' ## remove old versions of files for fname in [chunksFilePath,outFilePath,tmpFilePath]: if os.path.exists(fname): os.remove(fname) ## extract the code from the file self.output_text("EXTRACTING CODE...") compileCmd = '"%s" "%s" -i "%s" -o "%s"'%(self.pythonPath,self.parsePath, filePath,chunksFilePath) self.run_subprocess(compileCmd) ## run the embedded code if os.path.exists(chunksFilePath): self.output_text("RUNNING CODE (%s)..."%(fileLanguage)) compileCmd = '"%s" "%s" > "%s"'%(langCmd,chunksFilePath,outFilePath) self.run_subprocess(compileCmd) else: self.output_text("EXITING EARLY... could not find extracted code") return False ## exit early on error goFlag = self.check_standard_error(self.stdErr) if goFlag == False: self.output_text("EXITING EARLY... ERROR found in embedded code") return False ## reassemble the *.rst file with code results if os.path.exists(outFilePath): self.output_text("\nREASSEMBLING CODE AND RESULTS...") compileCmd = '"%s" "%s" -i "%s" -o "%s" -l %s'%(self.pythonPath, assemblePath, filePath, outFilePath, fileLanguage) self.run_subprocess(compileCmd) else: self.output_text("EXITING EARLY... there was a problem running the embedded code") return False ## overwrite the old rst file if os.path.exists(tmpFilePath): shutil.move(tmpFilePath,targetFilePath) self.goFlag = True self.output_text("BUILD COMPLETED SUCCESFULLY.") if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] if editor.textScreen.showMessages == True: editor.textScreen.toggle_message_btn() return True def show_error(self): """ show error in messages """ currentIdx = self.controller.currentFileIndex if self.mainWindow != None: self.mainWindow.display_info("Build did not complete correctly") editor = self.mainWindow.controller.editorList[currentIdx] if editor.textScreen.showMessages == False: editor.textScreen.toggle_message_btn() else: print "WARNING: Build did not complete correctly" return def ensure_valid_build(self,texFilePath): """ ensure build completed correctly """ currentIdx = self.controller.currentFileIndex if not os.path.exists(texFilePath): self.show_error() return False else: self.output_text("BUILD COMPLETED SUCCESFULLY.") if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] if editor.textScreen.showMessages == True: editor.textScreen.toggle_message_btn() return True def on_subprocess_complete(self): """ on completion of a subprocess return to editor mode """ if self.mainWindow != None: self.mainWindow.transitions.move_to_editor() ## debugging #print 'output',self.stdOut,self.stdErr def run_subprocess(self,cmd,background=False,clear=True): self.stdErr, self.stdOut = None, None ## create a thread to check status of subprocess def target(process,nga): while process.thread.is_alive(): currentIdx = nga.controller.currentFileIndex if nga.mainWindow != None: editor = nga.controller.editorList[currentIdx] editor.clear_messages() time.sleep(1) nga.output_text(process.cmd) stdOut = process.stdOut stdErr = process.stdErr if stdOut == None or len(stdOut) == 0: stdOut = '' if stdErr == None or len(stdErr) == 0: stdErr = '' if stdOut != '': nga.output_text("\n"+stdOut) if stdErr != '': ## ignore certain stderr if re.search("\[2K\n",stdErr): stdErr = '' continue nga.output_text("\n"+stdErr) self.stdErr, self.stdOut = stdErr, stdOut nga.on_subprocess_complete() ## move to appropriate mode if self.mainWindow != None: self.mainWindow.transitions.move_to_subprocess() self.mainWindow.process = RunSubprocess(cmd) process = self.mainWindow.process self.mainWindow.transitions.update_ui() else: process = RunSubprocess(cmd) ## begin the threaded subprocess returnCode = process.run(timeout=None) ## run the process in the background if background == True: if self.mainWindow != None: self.mainWindow.transitions.move_to_editor() return True ## start a thread to check on process status if self.mainWindow != None: self.mainWindow.waitThread = threading.Thread(target=target(process,self)) waitThread = self.mainWindow.waitThread else: waitThread = threading.Thread(target=target(process,self)) waitThread.start() def compile_pdf(self,verbose=True,recompile=False): """ uses system calls to compile the latex code to pdf """ # variables if self.mainWindow != None: self.mainWindow.ensure_tab_is_current() currentIdx = self.controller.currentFileIndex filePath = self.controller.filePathList[currentIdx] filePathBase = os.path.split(filePath)[0] fileName = self.controller.fileNameList[currentIdx] ## error checking isActive = self.is_active_project(filePath) if not isActive: return isTemplate = self.is_template() if isTemplate == True: return ## clear the text if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] editor.clear_messages() ## more variables dirPath = self.controller.ensure_dir_present(filePath) if re.search("\.rnw|\.nw",fileName,flags=re.IGNORECASE): texFileName = re.sub("\.rnw|\.nw",".tex",fileName,flags=re.IGNORECASE) texFilePath = os.path.join(dirPath,texFileName) pdfFileName = re.sub("\.rnw|\.nw",".pdf",fileName,flags=re.IGNORECASE) pdfFileName = re.sub("\s+","_",pdfFileName) pdfFilePath = os.path.join(dirPath,pdfFileName) projectType = 'nw' else: sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) texFileName = sl.log['project_name'] + ".tex" texFilePath = os.path.join(dirPath,"_build",texFileName) pdfFileName = sl.log['project_name'] + ".pdf" pdfFileName = re.sub("\s+","_",pdfFileName) pdfFilePath = os.path.join(dirPath,"_build",pdfFileName) projectType = 'sphinx' ## if sphinx project if projectType == 'sphinx': self.output_text("BUILDING SPHINX (LaTeX)...") sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) texFileName = self.sphinxLog.log['project_name'] + ".tex" texFilePath = os.path.join(dirPath,"_build",texFileName) ## remove old versions of files for fname in [texFilePath]: if os.path.exists(fname): os.remove(fname) compileCmd = "%s -b latex %s %s"%(self.sphinxPath,dirPath,os.path.join(dirPath,"_build")) self.run_subprocess(compileCmd) goFlag = self.ensure_valid_build(texFilePath) if goFlag == False: self.output_text("EXITING EARLY... Could not create tex file.") return False if not os.path.exists(texFilePath): errMsg = "'%s' does not exist\nDid you build the file successfully?"%(texFileName) self.display_error(errMsg) return ## compile ## with errors nonstopmode will do its best to compile, batchmode will supress pdf output if projectType == 'nw': texOut = dirPath else: texOut = os.path.join(dirPath,'_build') latexCompileCmd = '"%s" -interaction=nonstopmode -output-directory %s "%s"'%(self.latexPath,texOut,texFilePath) ## remove pdf files for fname in [pdfFilePath]: if os.path.exists(fname): os.remove(fname) ## first pass to match citations and refs self.run_subprocess(latexCompileCmd) goFlag = self.check_pdf_compile(pdfFilePath) if goFlag == False: return ## recompile if specified if recompile: self.run_subprocess(latexCompileCmd) ## check to see if there was a bib file bibFilePath = None fid = open(filePath,'r') for linja in fid: if re.search("\{.+\.bib\}",linja): match = re.findall("\{.+\.bib\}",linja) bibFileName = match[0][1:-1] bibFilePath = os.path.join(filePathBase,bibFileName) fid.close() ## if there was a bib if bibFilePath != None: cwd = os.getcwd() os.chdir(texOut) bibtexPath = re.sub('pdflatex','bibtex',self.latexPath) compileCmd = '"%s" "%s"'%(bibtexPath,texFileName[:-4]) self.run_subprocess(compileCmd) os.chdir(cwd) ## compile twice for bib #if os.path.exists(pdfFilePath): self.run_subprocess(latexCompileCmd) #self.run_subprocess(latexCompileCmd) ## check to see that everything worked goFlag = self.check_pdf_compile(pdfFilePath) if goFlag == False: return ## move pdf into same directory as src file if os.path.exists(pdfFilePath) == False: print "ERROR: NoGuiAnalysis.compile_latex --- could not find pdfFileName to move" return shutil.move(pdfFilePath,os.path.join(filePathBase,pdfFileName)) def compile_html(self,verbose=True): """ use system calls to compile either latex to html or rst to html """ # variables if self.mainWindow != None: self.mainWindow.ensure_tab_is_current() currentIdx = self.controller.currentFileIndex filePath = self.controller.filePathList[currentIdx] filePathBase = os.path.split(filePath)[0] fileName = self.controller.fileNameList[currentIdx] ## error checking isActive = self.is_active_project(filePath) if not isActive: return isTemplate = self.is_template() if isTemplate == True: return ## clear the text if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] editor.clear_messages() ## more variables dirPath = self.controller.ensure_dir_present(filePath) ## determine the type of project if re.search("\.rnw|\.nw",fileName,flags=re.IGNORECASE): projectType = 'latex' elif re.search("\.rst",fileName,flags=re.IGNORECASE): sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) projectType = 'sphinx' else: errMsg = "Invalid source file for compile_html -- skipping compile\n%s"%fileName self.display_error(errMsg) if projectType == 'sphinx': ## before building remove old html htmlFilePath = os.path.join(dirPath,"_build","index.html") if os.path.exists(htmlFilePath): os.remove(htmlFilePath) ## use sphinx build to create the html document self.output_text("BUILDING WITH SPHINX (Sphinx)...") sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) compileCmd = "%s -b html %s %s"%(self.sphinxPath,dirPath,os.path.join(dirPath,"_build")) self.run_subprocess(compileCmd) else: htmlFileName = re.sub("\.rnw|\.nw",".html",fileName,flags=re.IGNORECASE) htmlFilePath = os.path.join(dirPath,htmlFileName) if os.path.exists(htmlFilePath): os.remove(htmlFilePath) ## use external program i.e. latex2html to create the html documents self.output_text("BUILDING HTML (LaTeX)...") sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) ## ensure we have valid program to build if self.latex2htmlPath == None: errMsg = "No program is specified for LaTeX to HTML conversion\nGo to Preferences" if self.mainWindow != None: self.mainWindow.display_info(errMsg) else: print errMsg return targetFilePath = os.path.join(dirPath,fileName) compileCmd = '"%s" "%s"'%(self.latex2htmlPath,targetFilePath) self.run_subprocess(compileCmd) ## point to main html file fileNameBase = re.sub("\.rnw|\.nw","",fileName,flags=re.IGNORECASE) htmlFilePath = os.path.join(dirPath,fileNameBase,'index.html') ## check that html was created succesfully goFlag = self.check_standard_error(self.stdErr) if goFlag == False: self.output_text("EXITING EARLY... ERROR: html was not created succesfully") return False ## ensure html was created if os.path.exists(htmlFilePath) == False: errMsg = "The HTML did not compile correctly \n%s"%htmlFilePath self.display_error(errMsg) else: if self.mainWindow != None: if self.controller.editorList[currentIdx].textScreen.showMessages == True: self.controller.editorList[currentIdx].textScreen.toggle_message_btn() def check_pdf_compile(self,pdfFilePath): currentIdx = self.controller.currentFileIndex if not os.path.exists(pdfFilePath): errMsg = "LaTeX did not compile correctly" self.display_error(errMsg) if self.mainWindow != None: self.mainWindow.display_info(errMsg) if self.controller.editorList[currentIdx].textScreen.showMessages == False: self.controller.editorList[currentIdx].textScreen.toggle_message_btn() else: print "ERROR: " + errMsg return False else: self.output_text("PDF CREATED SUCCESFULLY.") if self.mainWindow != None: if self.controller.editorList[currentIdx].textScreen.showMessages == True: self.controller.editorList[currentIdx].textScreen.toggle_message_btn() return True def view_pdf(self): ''' uses system calls to view the pdf ''' ## variables if self.mainWindow != None: self.mainWindow.ensure_tab_is_current() isTemplate = self.is_template() if isTemplate == True: return currentIdx = self.controller.currentFileIndex filePath = self.controller.filePathList[currentIdx] filePathBase = os.path.split(filePath)[0] fileName = self.controller.fileNameList[currentIdx] dirPath = self.controller.ensure_dir_present(filePath) ## error checking isActive = self.is_active_project(filePath) if not isActive: return ## clear the text if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] editor.clear_messages() ## more variables if re.search("\.rnw|\.nw",fileName,flags=re.IGNORECASE): pdfFileName = re.sub("\.rnw|\.nw",".pdf",fileName,flags=re.IGNORECASE) else: sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) pdfFileName = sl.log['project_name'] + ".pdf" pdfFilePath = os.path.join(filePathBase,pdfFileName) if not os.path.exists(pdfFilePath): errMsg = "'%s' does not exist\nDid you run the PDF compilation script?"%(pdfFilePath) self.display_error(errMsg) return pdfViewerPath = self.controller.get_pdfviewer_path() if pdfViewerPath == None: errMsg = "No pdf viewer found -- do you have one installed?" self.display_error(errMsg) ## view the pdf pdfViewerCmd = '"%s" "%s"'%(pdfViewerPath,pdfFilePath) if self.mainWindow == None: return self.run_subprocess(pdfViewerCmd,background=True) if self.mainWindow != None: if self.controller.editorList[currentIdx].textScreen.showMessages == True: self.controller.editorList[currentIdx].textScreen.toggle_message_btn() def view_html(self): ''' uses webbrowser to open the report ''' ## variables if self.mainWindow != None: self.mainWindow.ensure_tab_is_current() isTemplate = self.is_template() if isTemplate == True: return currentIdx = self.controller.currentFileIndex filePath = self.controller.filePathList[currentIdx] filePathBase = os.path.split(filePath)[0] fileName = self.controller.fileNameList[currentIdx] dirPath = self.controller.ensure_dir_present(filePath) ## error checking isActive = self.is_active_project(filePath) if not isActive: return ## clear the text if self.mainWindow != None: editor = self.mainWindow.controller.editorList[currentIdx] editor.clear_messages() ## open the file in a browser if re.search("\.rnw|\.nw",fileName,flags=re.IGNORECASE): htmlFilePath = os.path.join(dirPath,re.sub("\.rnw|\.nw",".html",fileName,flags=re.IGNORECASE)) else: sl = SphinxLogger(os.path.join(dirPath,'sphinx.log')) htmlFilePath = os.path.join(dirPath,"_build",'index.html') if not os.path.exists(htmlFilePath): errMsg = "'%s' does not exist.<p>Try HTML compilation again"%(os.path.split(htmlFilePath)[-1]) self.display_error(errMsg) return webbrowser.open_new("file://"+os.path.realpath(htmlFilePath)) if self.mainWindow != None: if self.controller.editorList[currentIdx].textScreen.showMessages == True: self.controller.editorList[currentIdx].textScreen.toggle_message_btn()