class Renderer(Overlay):
def __init__(self, win, parser='rst', writer='html4', style=''):
super(Renderer, self).__init__()
self.webview = WebView()
self.webview.connect("mouse-target-changed", self.on_mouse)
self.webview.connect("context-menu", self.on_context_menu)
self.webview.connect("button-release-event", self.on_button_release)
self.add(self.webview)
controller = self.webview.get_find_controller()
self.search_done = None
controller.connect("found-text", self.on_found_text)
controller.connect("failed-to-find-text", self.on_faild_to_find_text)
self.label = Label()
self.label.set_halign(Align.START)
self.label.set_valign(Align.END)
self.add_overlay(self.label)
self.link_uri = None
self.context_button = 3 # will be rewrite by real value
self.set_writer(writer)
self.set_parser(parser)
self.style = style
self.tab_width = 8
self.__win = win
@property
def position(self):
self.__position = -1
self.webview.run_javascript(JS_POSITION, None,
self.on_position_callback, None)
while self.__position < 0:
# this call at this place do problem, when Gdk.threads_init
main_iteration()
return self.__position
def on_position_callback(self, webview, result, data):
try:
js_res = webview.run_javascript_finish(result)
self.__position = js_res.get_js_value().to_double()
except Error:
self.__position = 0
def on_mouse(self, webview, hit_test_result, modifiers):
self.link_uri = None
if hit_test_result.context_is_link():
self.link_uri = hit_test_result.get_link_uri()
text = "link: %s" % self.link_uri
elif hit_test_result.context_is_image():
text = "image: %s" % hit_test_result.get_image_uri()
elif hit_test_result.context_is_media():
text = "media: %s" % hit_test_result.get_media_uri()
else:
if self.label.is_visible():
self.label.hide()
return
self.label.set_markup(MARKUP % text.replace("&", "&"))
self.label.show()
def on_context_menu(self, webview, menu, event, hit_test_result):
self.context_button = event.button.button
return True # disable context menu for now
def on_button_release(self, webview, event):
"""Catch release-button only when try to follow link.
Context menu is catch by webview before this callback.
"""
if event.button == self.context_button:
return True
if self.link_uri:
if self.link_uri.startswith("file://"): # try to open source
self.find_and_opendocument(self.link_uri[7:].split('#')[0])
else:
show_uri_on_window(None, self.link_uri, 0)
return True
def find_and_opendocument(self, file_path):
ext = splitext(file_path)[1]
if not ext:
for EXT in LANGS.keys():
tmp = file_path + EXT
if exists(tmp):
file_path = tmp
ext = EXT
break
if ext in LANGS:
self.__win.open_document(file_path)
elif exists(file_path):
show_uri_on_window(None, "file://" + file_path, 0)
else:
dialog = FileNotFoundDialog(self.__win, file_path)
dialog.run()
dialog.destroy()
def set_writer(self, writer):
assert writer in WRITERS
self.__writer = WRITERS[writer]
klass = self.__writer['class']
self.writer_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_writer(self):
return self.__writer['key']
def set_parser(self, parser):
assert parser in PARSERS
self.__parser = PARSERS[parser]
klass = self.__parser['class']
self.parser_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_parser(self):
return self.__parser['key']
def set_style(self, style):
self.style = style
idle_add(self.do_render)
def get_style(self):
return self.style
def set_tab_width(self, width):
self.tab_width = width
def render_output(self):
if getattr(self, 'src', None) is None:
return False, "", "text/plain"
try:
if self.__parser['class'] is None:
html = NOT_FOUND.format(**self.__parser)
elif self.__writer['class'] is None:
html = NOT_FOUND.format(**self.__writer)
elif issubclass(self.__parser['class'], JSONPreview):
try:
json = loads(self.src)
return (False,
dumps(json,
sort_keys=True,
ensure_ascii=False,
indent=4,
separators=(',', ': ')), 'application/json')
except ValueError as e:
return False, DATA_ERROR % ('JSON', str(e)), "text/html"
else:
if not issubclass(self.__parser['class'], HtmlPreview):
settings = {
'warning_stream': StringIO(),
'embed_stylesheet': True,
'tab_width': self.tab_width,
'file_name': self.file_name
}
if self.style:
settings['stylesheet'] = self.style
settings['stylesheet_path'] = []
kwargs = {
'source': self.src,
'parser': self.parser_instance,
'writer': self.writer_instance,
'writer_name': 'html',
'settings_overrides': settings
}
if self.__writer['key'] == 'pep':
kwargs['reader_name'] = 'pep'
kwargs.pop('parser') # pep is allways rst
html = publish_string(**kwargs).decode('utf-8')
return True, html, 'text/html'
else:
if version_info.major == 2:
html = self.src.decode("utf-8")
else:
html = self.src
# output to file or html preview
return False, html, 'text/html'
except DataError as e:
return False, DATA_ERROR % ('Data', e), 'text/html'
except NotImplementedError:
exc_str = format_exc()
return False, NOT_IMPLEMENTED_ERROR % exc_str, 'text/html'
except BaseException:
exc_str = format_exc()
return False, EXCEPTION_ERROR % exc_str, 'text/html'
def do_render(self):
state, html, mime_type = self.render_output()
if state:
if self.pos > 1: # vim
a, b = len(self.src[:self.pos]), len(self.src[self.pos:])
position = (float(a) / (a + b)) if a or b else 0
else:
position = self.pos
html += SCROLL % position
if html and self.__win.runing:
file_name = self.file_name or get_home_dir()
self.webview.load_bytes(Bytes(html.encode("utf-8")), mime_type,
"UTF-8", "file://" + file_name)
def render(self, src, file_name, pos=0):
self.src = src
self.pos = pos
self.file_name = file_name
idle_add(self.do_render)
def print_page(self):
po = PrintOperation.new(self.webview)
po.connect("failed", self.on_print_failed)
po.run_dialog(self.__win)
def on_print_failed(self, po, error):
# FIXME: if dialog is used, application will lock :-(
log_default_handler("Application", LogLevelFlags.LEVEL_WARNING,
error.message)
def do_next_match(self, text):
controller = self.webview.get_find_controller()
if controller.get_search_text() != text:
self.search_done = None
controller.search(text, FindOptions.WRAP_AROUND, MAXUINT)
while self.search_done is None:
main_iteration()
elif self.search_done:
controller.search_next()
return self.search_done
def do_previous_match(self, text):
controller = self.webview.get_find_controller()
if controller.get_search_text() != text:
self.search_done = None
controller.search(text,
FindOptions.WRAP_AROUND | FindOptions.BACKWARDS,
MAXUINT)
while self.search_done is None:
main_iteration()
elif self.search_done:
controller.search_previous()
return self.search_done
def stop_search(self):
controller = self.webview.get_find_controller()
controller.search_finish()
def on_found_text(self, controller, count):
self.search_done = True
def on_faild_to_find_text(self, controller):
self.search_done = False
def scroll_to_position(self, position):
if position is not None:
self.pos = position
if self.pos > 1: # vim
a, b = len(self.src[:self.pos]), len(self.src[self.pos:])
position = (float(a) / (a + b)) if a or b else 0
else:
position = self.pos
self.webview.run_javascript(JS_SCROLL % position, None, None, None)
class Renderer(Overlay):
def __init__(self, win, parser='rst', writer='html4', style=''):
super(Renderer, self).__init__()
scrolled = ScrolledWindow.new(None, None)
scrolled.set_policy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC)
self.sb = scrolled.get_vscrollbar()
self.add(scrolled)
self.webview = WebView()
self.webview.connect("mouse-target-changed", self.on_mouse)
scrolled.add(self.webview)
self.label = Label()
self.label.set_halign(Align.START)
self.label.set_valign(Align.END)
self.add_overlay(self.label)
self.set_writer(writer)
self.set_parser(parser)
self.style = style
self.tab_width = 8
self.__win = win
def on_mouse(self, web_view, hit_test_result, modifiers):
if hit_test_result.context_is_link():
text = "link: %s" % hit_test_result.get_link_uri()
elif hit_test_result.context_is_image():
text = "image: %s" % hit_test_result.get_image_uri()
elif hit_test_result.context_is_media():
text = "media: %s" % hit_test_result.get_media_uri()
else:
if self.label.is_visible():
self.label.hide()
return
self.label.set_markup(MARKUP % text)
self.label.show()
def set_writer(self, writer):
assert writer in WRITERS
self.__writer = WRITERS[writer]
klass = self.__writer['class']
self.writer_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_writer(self):
return self.__writer['key']
def set_parser(self, parser):
assert parser in PARSERS
self.__parser = PARSERS[parser]
klass = self.__parser['class']
self.parser_instance = klass() if klass is not None else None
idle_add(self.do_render)
def get_parser(self):
return self.__parser['key']
def set_style(self, style):
self.style = style
idle_add(self.do_render)
def get_style(self):
return self.style
def set_tab_width(self, width):
self.tab_width = width
def render_output(self):
if getattr(self, 'src', None) is None:
return False, "", "text/plain"
try:
if self.__parser['class'] is None:
html = NOT_FOUND.format(**self.__parser)
elif self.__writer['class'] is None:
html = NOT_FOUND.format(**self.__writer)
elif issubclass(self.__parser['class'], JSONPreview):
try:
json = loads(self.src)
return (False, dumps(json, sort_keys=True,
ensure_ascii=False,
indent=4, separators=(',', ': ')),
'application/json')
except ValueError as e:
return False, DATA_ERROR % ('JSON', str(e)), "text/html"
else:
if not issubclass(self.__parser['class'], HtmlPreview):
settings = {
'warning_stream': StringIO(),
'embed_stylesheet': True,
'tab_width': self.tab_width
}
if self.style:
settings['stylesheet'] = self.style
settings['stylesheet_path'] = []
kwargs = {'source': self.src,
'parser': self.parser_instance,
'writer': self.writer_instance,
'writer_name': 'html',
'settings_overrides': settings}
if self.__writer['key'] == 'pep':
kwargs['reader_name'] = 'pep'
kwargs.pop('parser') # pep is allways rst
html = publish_string(**kwargs).decode('utf-8')
return True, html, 'text/html'
else:
if version_info.major == 2:
html = self.src.decode("utf-8")
else:
html = self.src
# output to file or html preview
return False, html, 'text/html'
except DataError as e:
return False, DATA_ERROR % ('Data', e), 'text/html'
except BaseException:
exc_str = format_exc()
return False, EXCEPTION_ERROR % exc_str, 'text/html'
def do_render(self):
state, html, mime_type = self.render_output()
if state:
a, b = len(self.src[:self.pos]), len(self.src[self.pos:])
position = (float(a)/(a+b)) if a or b else 0
html += SCROLL % position
if html and self.__win.runing:
file_name = self.file_name or get_home_dir()
self.webview.load_bytes(Bytes(html.encode("utf-8")),
mime_type, "UTF-8", "file://"+file_name)
def render(self, src, file_name, pos=0):
self.src = src
self.pos = pos
self.file_name = file_name
idle_add(self.do_render)
def print_page(self):
po = PrintOperation.new(self.webview)
po.connect("failed", self.on_print_failed)
po.run_dialog(self.__win)
def on_print_failed(self, po, error):
# FIXME: if dialog is used, application will lock :-(
log_default_handler("Application", LogLevelFlags.LEVEL_WARNING,
error.message)
class TabbedCanvas(Gtk.EventBox):
basePath=""
counter=0
saveAsFilename=""
fileName=""
data=""
currentPageIndex=""
hbox=""
#property to hold <filename,notebook page> pair
pageMap=dict()
def __init__(self):
Gtk.EventBox.__init__(self)
#Adding HBox
self.mainbox=Gtk.HPaned()
#self.mainbox.orientation(gtk.Orientation.VERTICAL #gtk.HBox()
self.elementBox=Gtk.VBox()
scrolled_window = Gtk.VPaned()#gtk.ScrolledWindow()
scrolled_window.set_border_width(5)
scrolled_window.set_size_request(300, 300)
scrolled_window.add(self.elementBox)
self.treestore=Gtk.TreeStore(str)
self.treestore.clear()
self.exampleNode=self.treestore.append(None,[_("Examples")])
#self.newitem=self.treestore.append(self.exampleNode,["test1"])
self.programNode=self.treestore.append(None,[_("Your Programs")])
#adding treeview
self.treeview=Gtk.TreeView()
#adding treeviewcolumn
self.tvcolumn=Gtk.TreeViewColumn(_("Explorer"))
self.cell=Gtk.CellRendererText()
self.tvcolumn.pack_start(self.cell,True)
self.tvcolumn.add_attribute(self.cell,"text",0)
self.treeview.append_column(self.tvcolumn)
self.treeview.set_model(self.treestore)
#add handler for row-activated signal
self.treeview.connect('row-activated',self.openSelectedFile)
#changed was causing different behavior as when treeview is refreshed, it calls openSelected, thus opening all files under this section
#self.treeview.get_selection().connect("changed", self.openSelectedFile)
#create a scrolled window for explorer
self.explorerScrollWindow=Gtk.ScrolledWindow()
self.explorerScrollWindow.set_policy(Gtk.PolicyType.NEVER,Gtk.PolicyType.AUTOMATIC);
self.explorerScrollWindow.add(self.treeview)
self.explorerScrollWindow.set_size_request(100,650)
self.elementBox.pack_start(self.explorerScrollWindow,False,False,0)
#self.elementBox.pack_start(self.btn2,False,False,0)
#Adding Notebook
self.notebook=Notebook()
self.notebook.tab_curvature=100
self.notebook.set_scrollable(True)
self.notebook.show()
#Adding Notebook pages
self.addPage(None,None)
self.mainbox.add(scrolled_window)
self.mainbox.add(self.notebook)
self.add(self.mainbox)
#method to add a page to Notebook
def addPage(self,textBuffer,pageTitle):
print "INSIDE_ADD_PAGE"
caption=_("Untitled"+str(self.counter))
#add hbox
self.hbox=Gtk.HBox();
self.hbox.show();
#create text_buffer
self.sourceBuffer= GtkSource.Buffer()
#add textview
self.textview=GtkSource.View()
self.textview.set_buffer(self.sourceBuffer)
self.textview.set_show_line_numbers(True)
self.textview.set_show_line_marks(True)
self.textview.set_size_request(250,400)
self.setLanguage(self.textview)
#check for textBuffer passed as param
if textBuffer!=None:
#set the textbuffer data to editor
start, end = textBuffer.get_bounds()
self.sourceBuffer.set_text(textBuffer.get_text(start, end, True))
#add vpane
self.vpane=Gtk.VPaned();
#add scroll to text view
self.scroll=Gtk.ScrolledWindow();
self.scroll.set_policy(Gtk.PolicyType.NEVER,Gtk.PolicyType.AUTOMATIC);
self.scroll.add_with_viewport(self.textview)
self.scroll.set_size_request(250,400)
self.scroll.show()
self.vpane.add(self.scroll)
#add scroll to text view
self.opScroll= Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
#create Vte Terminal
self.vteObject=Vte.Terminal()
self.opScroll.pack_start(self.vteObject, True, True, 0)
self.outsb = Gtk.Scrollbar(orientation=Gtk.Orientation.VERTICAL)
self.outsb.set_adjustment(self.vteObject.get_vadjustment())
self.outsb.show()
self.opScroll.pack_start(self.outsb, False, False, 0)
self.vteObject.set_colors(Gdk.color_parse('#000000'),Gdk.color_parse('#E7E7E7'),[])
self.vteObject.set_size_request(200,200)
self.vteObject.show()
#self.opScroll.set_size_request(250,200)
self.opScroll.show()
print "VTE_KARTIK:",self.vteObject.get_vadjustment()
self.vpane.add(self.opScroll)
self.vpane.show()
self.hbox.pack_start(self.vpane,True,True,0)
self.textview.show()
#attach text-change listener for buffer
self.attachTextChangedListener(self.hbox)
self.hbox.set_size_request(250, 300)
#if pageTitle is none then give a Untitled caption
if pageTitle==None:
self.newlabel=Label(caption)
else:
self.newlabel=Label(pageTitle)
#self.newlabel.set_size_request(75,30)
self.resizeLabel(self.newlabel)
self.newlabel.show()
self.notebook.append_page(self.hbox,self.newlabel)
#assigning notebook page for the filename
#self.pageMap[self.newlabel.get_text()]=self.hbox
self.addPageToPageMap(self.newlabel.get_text(),self.hbox)
self.counter=self.counter+1
print "Curr :",self.pageMap
self.selectFileNamePage(self.newlabel.get_text())
#method to add page to pageMap
def addPageToPageMap(self,fileName,hbox):
print "BEFORE_CURRENT_PAGE_MAP:",self.pageMap
print "addPageToPageMap_called_for:",fileName
try:
#assigning notebook page for the filename
self.pageMap[fileName]=hbox
print "Page:",fileName," added to pageMap"
except:
print "Page already exist in pageMap"
print "AFTER_CURRENT_PAGE_MAP:",self.pageMap
#method to remove page from pageMap
def removePageFromPageMap(self,fileName):
try:
print "looking for page:",fileName, " in pageMap for removal"
del self.pageMap[fileName]
print "Page:",fileName," removed from pageMap"
except:
print "Unable to remove page from pageMap"
#method to resize the tab label to appropriate dimension
def resizeLabel(self,label):
label.set_size_request(label.get_width_chars(),40)
#method to get label for tab
def resizeSelectedTabLabel(self):
label=self.getSelectedTabLabel()
self.resizeLabel(label)
#method to get hbox for selected tab
def getSelectedTabHBox(self):
currentPageIndex=self.notebook.get_current_page()
print "current page number:",currentPageIndex
hbox=self.notebook.get_nth_page(currentPageIndex)
return hbox
#method to get tab label for selected tab
def getSelectedTabLabel(self):
hbox=self.getSelectedTabHBox()
label=self.notebook.get_tab_label(hbox)
return label
#method to get textview for selected tab( code editor)
def getSelectedTabTextView(self):
hbox=self.getSelectedTabHBox()
children=hbox.get_children()#VPANED
#ScrolledWindow #Viewport #textview
textview=children[0].get_children()[0].get_children()[0].get_children()[0]
return textview
#method to get outputWindow text view for selected tab( output window)
def getSelectedTabOutputWindowTextView(self):
hbox=self.getSelectedTabHBox()
children=hbox.get_children() #ScrolledWindow #Viewport #textview
textview=children[0].get_children()[1].get_children()[0].get_children()[0]
return textview
#method to get text-buffer for selected tab( code editor)
def getSelectedTabTextBuffer(self):
hbox=self.getSelectedTabHBox()
textview=self.getSelectedTabTextView()
tvbuffer=textview.get_buffer()
return tvbuffer
#method to get text-buffer for selected tab( output window)
def getSelectedTabOutputWindowBuffer(self):
hbox=self.getSelectedTabHBox()
textview=self.getSelectedTabOutputWindowTextView()
tvbuffer=textview.get_buffer()
return tvbuffer
#method to get text-buffer for selected tab( output window)
def getSelectedTabVte(self):
hbox=self.getSelectedTabHBox()
children=hbox.get_children() #ScrolledWindow #Viewport #vte
vteObj=children[0].get_children()[1].get_children()[0]#.get_children()[0]
return vteObj
#method to remove the selected page
def removePage(self):
currentPageIndex=self.notebook.get_current_page()
print "Removing page number:",currentPageIndex
#remove page from pageMap first
fileName_to_be_removed=self.getSelectedTabLabel()
self.removePageFromPageMap(fileName_to_be_removed.get_text())
self.notebook.remove_page(currentPageIndex)
#method to delete the selected page and file
def deletePage(self):
del_filename=self.getSelectedTabLabel().get_text()
actualFileName=del_filename.replace('*','')
self.showConfirmDeleteDialog(actualFileName,self.basePath)
#method to confirm deletion operation
def showConfirmDeleteDialog(self,fileName,basePath):
print "show confirm delete dialog called"
self.deleteDialog=Gtk.Dialog(_("Oopsy Alert on Delete !"),None,0,None)
self.label = Gtk.Label(_("Are you sure you want to delete '"+fileName+"' ?"))
self.deleteDialog.vbox.pack_start(self.label,True,True,0)
#adding buttons
btnOk=Gtk.Button(_("Ok"))
btnOk.connect("clicked",self.hideConfirmDeleteDialogOnOK,fileName,basePath)
btnCancel=Gtk.Button(_("Cancel"))
btnCancel.connect("clicked",self.hideConfirmDeleteDialogOnCancel,basePath)
self.deleteDialog.action_area.pack_start(btnCancel,True,True,0)
self.deleteDialog.action_area.pack_start(btnOk, True, True, 0)
self.deleteDialog.set_size_request(150,150)
btnOk.show()
btnCancel.show()
self.label.show()
self.deleteDialog.show()
#method to hide confirm deletion operation and delete the file as user pressed OK
def hideConfirmDeleteDialogOnOK(self,widget,fileName,basePath):
print "hideConfirmDeleteDialogOnOK called"
self.deleteDialog.hide()
self.removePage()
fh=FileHandler()
fh.basePath=self.basePath
fh.deleteFile(fileName)
#refresh the explorer
self.refreshExplorer(self.basePath)
#method to hide confirm deletion operation as user pressed CANCEL
def hideConfirmDeleteDialogOnCancel(self,widget,basePath):
print "hideConfirmDeleteDialogOnCancel called"
self.deleteDialog.hide()
#method to apply text-changed callback to textview's text buffer
def attachTextChangedListener(self,hbox):
#HBOX #VPANED #SCROLL_WINDOW #ViewPort #TextView
textview=self.hbox.get_children()[0].get_children()[0].get_children()[0].get_children()[0]
print "L1:",self.hbox.get_children()[0]
print "L2:",self.hbox.get_children()[0].get_children()[0]
print "L3:",self.hbox.get_children()[0].get_children()[0].get_children()[0]
print "attached text changed listener to :",textview
tbuffer=textview.get_buffer()
tbuffer.connect("changed",self.showUnsavedTab)
print "\nAttached change listener"
#method that detects text-change in text buffer and indicates on tab with a * mark
def showUnsavedTab(self,widget):
label=self.getSelectedTabLabel()
oldTitle=label.get_text()
oldTitle=oldTitle.replace('*','')
oldTitle=oldTitle + '*'
label.set_text(oldTitle)
#method to set Language of sourceView with Language Manager
def setLanguage(self,sourceView):
self.lmgr=GtkSource.LanguageManager.get_default()
self.language=self.lmgr.get_language('cpp')
sourceView.get_buffer().set_language(self.language)
#method to open the selected file from the explorer
def openSelectedFile(self, widget, row, col):
model=self.treeview.get_model()
value = model[row][0]
print "Open Selected File called for :",value
filename=value
page_in_pageMap=None
#get page from pageMap and select already open tab for this file
try:
page_in_pageMap=self.pageMap[filename]
print "PAGE_MAP:",page_in_pageMap," for :",filename
self.selectFileNamePage(filename)
except:
print "NO_PAGE_IN_PAGE_MAP"
#create fileHandler instance
fh=FileHandler()
fh.basePath=self.basePath
fileData=fh.loadFileFromWorkspace(filename)
print "FILE_DATA:",fileData
text_buffer=Gtk.TextBuffer()
text_buffer.set_text(fileData)
if page_in_pageMap==None:
print "since no page in pageMap thus creating page"
self.addPage(text_buffer,filename)
#method to select the tab with a filename
def selectFileNamePage(self,filename):
h_box=self.pageMap[filename]
page_num=self.getPageNumberWithTabHBox(h_box)
self.notebook.set_current_page(page_num)
#method to get hbox for a hbox
def getPageNumberWithTabHBox(self,hbox):
page_number=self.notebook.page_num(hbox)
return page_number
#method to save the file on selected notebook page
def saveFile(self,basePath):
hbox=self.getSelectedTabHBox()
textview_buffer=self.getSelectedTabTextBuffer()
start, end = textview_buffer.get_bounds()
self.data=textview_buffer.get_text(start, end, True)
self.fileName=self.notebook.get_tab_label(hbox).get_text()
#check if file exists on drive
actualFilename=self.fileName.replace('*','')
fh=FileHandler()
fh.basePath=basePath
if fh.checkFileExists(actualFilename):
self.saveAsFilename=actualFilename
self.saveToDisk(basePath)
else:
self.showSaveDialog(basePath)
#print "HBOX has elements:",str(len(lst))
print "Got data:",self.data," with filename:",self.fileName
#method to show save dialog on click of save button
def showSaveDialog(self,basePath):
print "save dialog called"
self.dialog=Gtk.Dialog(_("Save Program"),None,0,None)
self.label = Gtk.Label(_("Save your program as :"))
self.entry=Gtk.Entry()
self.dialog.vbox.pack_start(self.label,True,True,0)
self.dialog.vbox.pack_start(self.entry,True,True,0)
#adding buttons
btnOk=Gtk.Button(_("Save"))
btnOk.connect("clicked",self.hideSaveDialogOnSave,basePath)
self.dialog.action_area.pack_start(btnOk, True, True, 0)
self.dialog.set_size_request(150,150)
btnOk.show()
self.label.show()
self.entry.show()
self.dialog.show()
#method to show alert dialog if file is unsaved and compile or executed is selected
def showAlertDialog(self,basePath,message):
print "show Alert dialog called"
self.alertDialog=Gtk.Dialog(_("Oopsy Alert"),None,0,None)
self.label = Gtk.Label(_(message))
self.alertDialog.vbox.pack_start(self.label,True,True,0)
#adding buttons
btnOk=Gtk.Button(_("Ok"))
btnOk.connect("clicked",self.hideAlertDialog,basePath)
self.alertDialog.action_area.pack_start(btnOk, True, True, 0)
self.alertDialog.set_size_request(150,150)
btnOk.show()
self.label.show()
self.alertDialog.show()
#method to hide alert dialog
def hideAlertDialog(self,widget,basePath):
print "hide Alert Dialog called"
self.alertDialog.hide()
#method to hide save-dialog and invoke saveToDisk--for actual saving
def hideSaveDialogOnSave(self,widget,basePath):
print "hideSaveDialog called"
self.saveAsFilename=self.entry.get_text()
print "got save as filename:",self.saveAsFilename
self.dialog.hide()
#check if file is saved as .c or .cpp file
isCFlag=self.saveAsFilename[-2:]
isCppFlag=self.saveAsFilename[-4:]
#if file is either of c or cpp file then proceed to save on disk
if isCFlag=='.c'or isCppFlag=='.cpp':
self.saveToDisk(basePath)
else:
self.showAlertDialog(basePath,"You must save your program as .c or .cpp file !")
#method to save data from text-buffer to disk as a file
def saveToDisk(self,basePath):
fh=FileHandler()
fh.basePath=basePath
fh.saveFile(self.saveAsFilename,self.data)
self.renameTabOnSave(self.saveAsFilename)
#get selected Tab HBox
hbox_obj=self.getSelectedTabHBox()
self.addPageToPageMap(self.saveAsFilename,hbox_obj)
#refresh the explorer
self.refreshExplorer(basePath)
#reselect file in explorer after explorer refresh
self.selectFileInExplorer(self.saveAsFilename)
#method to rename tab as save is clicked
def renameTabOnSave(self,fileName):
hbox=self.getSelectedTabHBox()
self.notebook.set_tab_label_text(hbox, fileName)
self.resizeSelectedTabLabel()
print "Tab renamed"
#method to compile selected file
def compileSelectedFile(self,basePath):
gc=GCCHandler()
gc.basePath=basePath
fn=self.getSelectedTabLabel().get_text()
actualFilename=fn.replace('*','')
#check if file is saved as .c or .cpp file
isCFlag=actualFilename[-2:]
isCppFlag=actualFilename[-4:]
#if file is either of c or cpp file then proceed otherwise show alert dialog asking user to save the file first.
if isCFlag=='.c'or isCppFlag=='.cpp':
vteObj=self.getSelectedTabVte()
compilationOutput=gc.compileFile(actualFilename,vteObj)
else:
self.showAlertDialog(basePath,"You must save the file before compiling or executing the program.")
#method to run selected file
def executeSelectedFile(self,basePath):
gc=GCCHandler()
gc.basePath=basePath
fn=self.getSelectedTabLabel().get_text()
actualFilename=fn.replace('*','')
#check if file is saved as .c or .cpp file
isCFlag=actualFilename[-2:]
isCppFlag=actualFilename[-4:]
#if file is either of c or cpp file then proceed otherwise show alert dialog asking user to save the file first.
if isCFlag=='.c'or isCppFlag=='.cpp':
vteObj=self.getSelectedTabVte()
executionOutput=gc.execute(actualFilename,vteObj)
else:
self.showAlertDialog(basePath,"You must save the file before compiling or executing the program.")
#clear the children under examples and your programs
def clearFilesInTreeView(self):
for row in self.treestore:
print "ROW:",row," NAME:",row[0]
rowIter=row.iterchildren()
try:
child=rowIter.next()
except:
print "No rows at all"
try:
while(child!=None):
print "Removing CHILD:",child[0]
self.treestore.remove(child.iter)
child=rowIter.next()
except:
print "No more rows !"
#method to select the row in TreeView
def selectFileInExplorer(self,fileName):
for row in self.treestore:
print "ROW:",row," NAME:",row[0]
rowIter=row.iterchildren()
try:
child=rowIter.next()
except:
print "No rows at all"
try:
while(child!=None):
print "Checking CHILD:",child[0], " for selecting:",fileName
if fileName==child[0]:
self.treeSel=self.treeview.get_selection()
self.treeSel.select_iter(child.iter)
print "TREE_SEL:",self.treeSel
break
child=rowIter.next()
except:
print "No more rows !"
#self.treeSel.select_path(
#refresh explorer
def refreshExplorer(self,basePath):
print "flushing treestore"
self.clearFilesInTreeView()
self.loadExplorer(basePath)
#method to load the explorer
def loadExplorer(self,basePath):
#flush all rows first
#self.refreshExplorer()
print "INSIDE_LOAD_EXPLORER"
print "basePath_in_TabControl:",basePath
ws=WorkspaceHandler(basePath)
#add child nodes to exampleNode-which shows all examples
print "ws.exampleList:",len(ws.exampleList)
for item in ws.exampleList:
print "adding item:",item," to examples:",self.exampleNode
self.newitem=self.treestore.append(self.exampleNode,[item])
#add child nodes to programNode-which shows your programs
print "ws.programList:",len(ws.programList)
for item in ws.programList:
print "adding item:",item," to programs:",self.programNode
self.newitem=self.treestore.append(self.programNode,[item])
#now expand all nodes
self.treeview.expand_all()
