class GridCellPopupMenu(wx.Menu):
def __init__(self, header=None):
wx.Menu.__init__(self)
self.fileOperations = FileOperations()
copyItem = wx.MenuItem(self, wx.NewIdRef(), "Copy")
copyItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="copy_edit_co.png"))
copyItemMenu = self.Append(copyItem)
self.Bind(wx.EVT_MENU, lambda e: self.onCopySelection(e), copyItemMenu)
pasteItem = wx.MenuItem(self, wx.NewIdRef(), "Paste")
pasteItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="paste_edit.png"))
pasteItemMenu = self.Append(pasteItem)
self.Bind(wx.EVT_MENU, lambda e: self.onPasteSelection(e), pasteItemMenu)
exportItem = wx.MenuItem(self, wx.NewIdRef(), "Export...")
exportItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="table_export.png"))
exportItemMenu = self.Append(exportItem)
self.Bind(wx.EVT_MENU, self.onExport, exportItemMenu)
resultSetCountItem = wx.MenuItem(self, wx.NewIdRef(), "Count rows")
resultSetCountItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="resultset_count.png"))
resultSetCountItemMenu = self.Append(resultSetCountItem)
self.Bind(wx.EVT_MENU, self.countRows, resultSetCountItemMenu)
def onPasteSelection(self, event):
logger.info('onPasteSelection')
self.GetWindow().paste()
# print "Item Two selected in the %s window" % self.WinName
def onCopySelection(self, event):
logger.info('onCopySelection')
self.GetWindow().copy()
# print "Item Two selected in the %s window" % self.WinName
def onExport(self, event):
logger.info('onExport')
# print "Item Two selected in the %s window" % self.WinName
pass
def countRows(self, event):
logger.info(f'countRows: {self.GetWindow().GetNumberRows()}')
dlg = wx.MessageDialog(self.GetWindow(), f'Row count : {self.GetWindow().GetNumberRows()}',
'Row Count',
wx.OK | wx.ICON_INFORMATION
# wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION
)
dlg.ShowModal()
dlg.Destroy()
class PropertiesBaseTreePanel(ExpansionState, TreeCtrl):
'''
Left navigation tree in preferences page
'''
def __init__(self, parent):
TreeCtrl.__init__(self, parent, style=wx.TR_DEFAULT_STYLE |
wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.BORDER_NONE)
self._il = None
self.BuildTreeImageList()
# if USE_CUSTOMTREECTRL:
# self.SetSpacing(10)
# self.SetWindowStyle(self.GetWindowStyle() & ~wx.TR_LINES_AT_ROOT)
self.SetInitialSize((100, 80))
def AppendItem(self, parent, text, image=-1, wnd=None):
item = TreeCtrl.AppendItem(self, parent, text, image=image)
return item
def BuildTreeImageList(self):
# imgList = wx.ImageList(16, 16)
#
# for png in _demoPngs:
# imgList.Add(catalog[png].GetBitmap())
#
# # add the image for modified demos.
# imgList.Add(catalog["custom"].GetBitmap())
#
# self.AssignImageList(imgList)
if self._il:
self._il.Destroy()
self._il = None
self._il = wx.ImageList(16, 16)
self.SetImageList(self._il)
self.ImageList.RemoveAll()
self.iconsDictIndex = {}
count = 0
self.fileOperations = FileOperations()
for imageName in ['preference.png', 'folder.png', 'folder_view.png', 'fileType_filter.png', 'usb.png', 'stop.png',
'java.png', 'python_module.png', 'xml.png', 'folderType_filter.png']:
self.ImageList.Add(self.fileOperations.getImageBitmap(imageName=imageName))
self.iconsDictIndex[imageName] = count
count += 1
def GetItemIdentity(self, item):
return self.GetItemData(item)
def Freeze(self):
if 'wxMSW' in wx.PlatformInfo:
return super(PropertiesBaseTreePanel, self).Freeze()
def Thaw(self):
if 'wxMSW' in wx.PlatformInfo:
return super(PropertiesBaseTreePanel, self).Thaw()
class MySplashScreen(SplashScreen):
def __init__(self):
# bmp = wx.Image(opj("../images/splash.png")).ConvertToBitmap()
self.fileOperations = FileOperations()
bmp = self.fileOperations.getImageBitmap(imageName="splash.png")
SplashScreen.__init__(self, bmp,
wx.adv.SPLASH_CENTRE_ON_SCREEN | wx.adv.SPLASH_TIMEOUT,
2000, None, -1)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.fc = wx.CallLater(1, self.ShowMain)
def OnClose(self, evt):
# Make sure the default handler runs too so this window gets
# destroyed
evt.Skip()
self.Hide()
# if the timer is still running then go ahead and show the
# main frame now
if self.fc.IsRunning():
self.fc.Stop()
self.ShowMain()
def ShowMain(self):
frame = EclipseMainFrame(None)
frame.Show()
if self.fc.IsRunning():
self.Raise()
class HeaderPanel(wx.Panel):
def __init__(self,
parent,
*args,
title="Python Project",
subTitle='',
imageName='python-wizban.png',
selectedPath=None,
**kw):
wx.Panel.__init__(self, parent, id=-1)
vBox = wx.BoxSizer(wx.VERTICAL)
hBox = wx.BoxSizer(wx.HORIZONTAL)
self.SetBackgroundColour(wx.WHITE)
self.fileOperations = FileOperations()
headerText = wx.StaticText(self, -1, title, (20, 10))
font = wx.Font(10, wx.FONTFAMILY_SCRIPT, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_BOLD)
headerText.SetFont(font)
subTitleText = wx.StaticText(self, -1, subTitle, (20, 10))
bmp = self.fileOperations.getImageBitmap(imageName=imageName)
rightsImage = wx.StaticBitmap(self, -1, bmp, (80, 150))
vBox1 = wx.BoxSizer(wx.VERTICAL)
vBox1.Add(headerText, 1, wx.EXPAND | wx.LEFT, 10)
vBox1.Add(subTitleText, 1, wx.EXPAND | wx.LEFT, 15)
hBox.Add(vBox1, 1, wx.EXPAND, 0)
hBox.Add(rightsImage, 0, wx.EXPAND, 0)
vBox.Add(hBox, 0, wx.EXPAND, 0)
vBox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.ALL, 0)
self.SetSizer(vBox)
self.SetAutoLayout(True)
class SelectWorkspaceFrame(wx.Frame):
'''
This is for select workspace
'''
def __init__(self,
parent,
title,
titleHead='',
subTitle='',
size=(550, 400),
style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE
| wx.SUNKEN_BORDER | wx.STAY_ON_TOP):
style = style & (~wx.MINIMIZE_BOX)
self.parent = parent
wx.Frame.__init__(self, None, -1, title, size=size, style=style)
self.title = title
self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
self.SetMinSize((100, 100))
self.fileOperations = FileOperations()
# set frame icon
icon = wx.Icon()
icon.CopyFromBitmap(
self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
sizer = wx.BoxSizer(wx.VERTICAL)
# self.buttonPanel = CreateButtonPanel(self)
####################################################################
self.newFileFrame = NewFilePanel(self,
title=titleHead,
subTitle=subTitle)
####################################################################
sizer.Add(self.newFileFrame, 1, wx.EXPAND)
# sizer.Add(self.buttonPanel, 0, wx.EXPAND)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
self.SetSizer(sizer)
self.Center()
# self.createStatusBar()
self.Show(True)
# self.Bind(wx.EVT_SIZE, self.OnSize)
def OnKeyUP(self, event):
# print "KEY UP!"
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
def OnCloseFrame(self, event):
self.Destroy()
def OnSize(self, event):
hsize = event.GetSize()
logger.debug(hsize)
class NewProjectFrame(wx.Frame):
'''
This is for new file and new folder.
'''
def __init__(self, parent, title, selectedPath=None, size=(350, 420),
style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE | wx.SUNKEN_BORDER | wx.STAY_ON_TOP):
style = style & (~wx.MINIMIZE_BOX)
self.parent = parent
wx.Frame.__init__(self, None, -1, title, size=size,
style=style)
self.title = title
self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
self.SetMinSize((100, 100))
self.fileOperations = FileOperations()
# set frame icon
icon = wx.Icon()
icon.CopyFromBitmap(self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
sizer = wx.BoxSizer(wx.VERTICAL)
# self.buttonPanel = CreateButtonPanel(self)
####################################################################
self.newPythonFrame = NewPythonPanel(self, title=title, selectedPath=selectedPath)
self.buttons = CreateButtonPanel(self)
####################################################################
sizer.Add(self.newPythonFrame, 1, wx.EXPAND)
sizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.ALL, 0)
sizer.Add(self.buttons, 0, wx.EXPAND | wx.ALL , 0)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
self.SetSizer(sizer)
self.Center()
# self.createStatusBar()
self.Show(True)
# self.Bind(wx.EVT_SIZE, self.OnSize)
def OnKeyUP(self, event):
# print "KEY UP!"
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
def OnCloseFrame(self, event):
try:
self.parent.refreshNode()
except Exception as e:
logger.error(e)
self.Destroy()
def OnSize(self, event):
hsize = event.GetSize()
logger.debug(hsize)
class OtherViewTreeFrame(wx.Frame):
def __init__(self,
parent,
title,
size=(313, 441),
style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE
| wx.SUNKEN_BORDER | wx.STAY_ON_TOP):
style = style & (~wx.MINIMIZE_BOX)
wx.Frame.__init__(self, parent, -1, title, size=size, style=style)
self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
self.SetMinSize((100, 100))
self.fileOperations = FileOperations()
# set frame icon
icon = wx.Icon()
icon.CopyFromBitmap(
self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
sizer = wx.BoxSizer(wx.VERTICAL)
self.buttonPanel = CreateButtonPanel(self)
####################################################################
self.otherViewTreePanel = OtherViewTreePanel(self)
####################################################################
sizer.Add(self.otherViewTreePanel, 1, wx.EXPAND)
sizer.Add(self.buttonPanel, 0, wx.EXPAND)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
self.SetSizer(sizer)
self.Center()
# self.createStatusBar()
self.Show(True)
# self.Bind(wx.EVT_SIZE, self.OnSize)
def OnKeyUP(self, event):
# print "KEY UP!"
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
def OnCloseFrame(self, event):
self.Destroy()
def OnSize(self, event):
hsize = event.GetSize()
logger.debug(hsize)
class SqlQueryFrame(wx.Frame):
def __init__(self,
parent,
Id=wx.ID_ANY,
Title="",
sqlText=None,
pos=wx.DefaultPosition,
size=wx.DefaultSize,
style=wx.DEFAULT_FRAME_STYLE | wx.SUNKEN_BORDER
| wx.STAY_ON_TOP):
style = style & (~wx.MINIMIZE_BOX)
wx.Frame.__init__(self, parent, Id, Title, pos, size, style)
self.fileOperations = FileOperations()
# set frame icon
icon = wx.Icon()
icon.CopyFromBitmap(
self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
sizer = wx.BoxSizer(wx.VERTICAL)
####################################################################
self.sqlQueryPanel = SqlQueryPanel(self, sqlText)
####################################################################
sizer.Add(self.sqlQueryPanel, 1, wx.EXPAND)
self.BindEvents()
self.Show(show=True)
def BindEvents(self):
# self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
def OnCloseWindow(self, event):
# self._mgr.UnInit()
event.Skip()
self.Destroy()
def OnKeyUP(self, event):
# print "KEY UP!"
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
class CreateButtonPanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
self.fileOperations = FileOperations()
sizer = wx.BoxSizer(wx.VERTICAL)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.openWithButton = wx.Button(self, wx.NewIdRef(), "Open Wit&h", size=(95, 26))
self.showInButton = wx.Button(self, wx.NewIdRef(), "Show In", size=(95, 26))
okButton = wx.Button(self, wx.NewIdRef(), "Open", size=(90, 26))
okButton.SetToolTip("Execute script to create table.")
self.Bind(wx.EVT_BUTTON, self.onOkClick, okButton)
self.Bind(wx.EVT_BUTTON, self.onOpenWithButton, self.openWithButton)
self.Bind(wx.EVT_BUTTON, self.onShowInButton, self.showInButton)
cancelButton = wx.Button(self, wx.NewIdRef(), "Cancel", size=(90, 26))
cancelButton.SetToolTip("Execute script to create table.")
self.Bind(wx.EVT_BUTTON, self.onCancelButtonClick, cancelButton)
self.openWithButton.SetBitmap(self.fileOperations.getImageBitmap(imageName='button_menu.png'),
# wx.LEFT # Left is the default, the image can be on the other sides too
wx.RIGHT
# wx.TOP
# wx.BOTTOM
)
self.showInButton.SetBitmap(self.fileOperations.getImageBitmap(imageName='button_menu.png'),
# wx.LEFT # Left is the default, the image can be on the other sides too
wx.RIGHT
# wx.TOP
# wx.BOTTOM
)
hbox.Add(self.showInButton)
hbox.Add(self.openWithButton)
hbox.Add(okButton)
hbox.Add(cancelButton)
# sizer.Add(cancelButton, 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.BOTTOM)
sizer.Add(hbox, 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.BOTTOM, 5)
# sizer.Add(vBox, 1, wx.EXPAND , 0)
self.SetAutoLayout(True)
self.SetSizer(sizer)
def onShowInButton(self, event):
logger.debug('showInButton')
menu = wx.Menu()
menu.Append(wx.ID_ANY, "Menu Item 1")
menu.Append(wx.ID_ANY, "Menu Item 2")
menu.Append(wx.ID_ANY, "Menu Item 3")
w, h = self.showInButton.GetSize()
x, y = self.showInButton.GetPosition()
self.PopupMenu(menu, (x, y + h))
def onOpenWithButton(self, event):
logger.debug('openWithButton')
menu = wx.Menu()
menu.Append(wx.ID_ANY, "Menu Item 1")
menu.Append(wx.ID_ANY, "Menu Item 2")
menu.Append(wx.ID_ANY, "Menu Item 3")
self.openWithButton
w, h = self.openWithButton.GetSize()
x, y = self.openWithButton.GetPosition()
self.PopupMenu(menu, (x, y + h))
def onOkClick(self, event):
logger.debug('onOkClick')
# TODO : need to implement
# sqlExecuter=SQLExecuter()
# obj=sqlExecuter.getObject()
# if len(obj[1])==0:
# sqlExecuter.createOpalTables()
# sqlExecuter.addNewConnectionRow(self.GetParent().CreateOpenConnectionPanel.filePath, self.GetParent().CreateOpenConnectionPanel.connectionNameText.GetValue())
# data = self.GetTopLevelParent().createImportingCsvPanel.data
# tableName = self.GetTopLevelParent().createImportingCsvPanel.tableNameText.GetValue()
# fileOperations = FileOperations()
# # data = fileOperations.readCsvFile(filePath=filePath, columnNameFirstRow=True, delimiter=",", quotechar='|')
# # print(len(data))
# # print(data)
# createTableScript = fileOperations.createTableScript(tableName=tableName, columnHeader=data[0])
# print(createTableScript)
# sqlList = fileOperations.sqlScript(tableName=tableName, data=data)
# print(sqlList)
# connectionName = self.GetTopLevelParent().connectionName
# importStatus = SQLUtils().importingData(connectionName=connectionName, sqlList=sqlList)
# dlg = wx.MessageDialog(self, "Some status",
# 'Importing data status',
# wx.OK | wx.ICON_INFORMATION
# #wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION
# )
# dlg.ShowModal()
# dlg.Destroy()
self.GetTopLevelParent().Destroy()
def onCancelButtonClick(self, event):
logger.debug('onCancelButtonClick')
self.GetTopLevelParent().Destroy()
class ResourceSearchResultListCtrl(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
sizer = wx.BoxSizer(wx.VERTICAL)
self.searchResult = {
# 1 : ["abc1.py", r"c:\1\asdf"],
# 2 : ["abc2.java", r"c:\1\asdf"],
# 3 : ["abcasdfasdfa3.java", r"c:\1\asdf"],
# 4 : ["abc4.java", r"c:\1\asdf"],
# 5 : ["abc5.properties", r"c:\1\asdf"],
# 6 : ["abc5.md", r"c:\1\asdf"],
# 7 : ["abc5.txt", r"c:\1\asdf"],
}
self.fileOperations = FileOperations()
self.list = ImprovedListCtrl(self, wx.NewIdRef(),
style=wx.LC_REPORT
# | wx.BORDER_SUNKEN
| wx.BORDER_NONE
| wx.LC_EDIT_LABELS
# | wx.LC_SORT_ASCENDING # disabling initial auto sort gives a
| wx.LC_NO_HEADER # better illustration of col-click sorting
| wx.LC_VRULES
| wx.LC_HRULES
| wx.LC_SINGLE_SEL
)
self.setImageList()
self.loadData(items={})
sizer.Add(self.list, 1, wx.EXPAND)
self.SetSizer(sizer)
self.SetAutoLayout(True)
self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected, self.list)
self.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnItemDeselected, self.list)
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated, self.list)
self.Bind(wx.EVT_LIST_DELETE_ITEM, self.OnItemDelete, self.list)
self.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick, self.list)
self.Bind(wx.EVT_LIST_COL_RIGHT_CLICK, self.OnColRightClick, self.list)
self.Bind(wx.EVT_LIST_COL_BEGIN_DRAG, self.OnColBeginDrag, self.list)
self.Bind(wx.EVT_LIST_COL_DRAGGING, self.OnColDragging, self.list)
self.Bind(wx.EVT_LIST_COL_END_DRAG, self.OnColEndDrag, self.list)
self.Bind(wx.EVT_LIST_BEGIN_LABEL_EDIT, self.OnBeginEdit, self.list)
self.Bind(wx.EVT_LIST_END_LABEL_EDIT, self.OnEndEdit, self.list)
self.list.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
self.list.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
# for wxMSW
self.list.Bind(wx.EVT_COMMAND_RIGHT_CLICK, self.OnRightClick)
# for wxGTK
self.list.Bind(wx.EVT_RIGHT_UP, self.OnRightClick)
def getColumnText(self, index, col):
item = self.list.GetItem(index, col)
return item.GetText()
def OnItemSelected(self, event):
logger.debug('OnItemSelected')
self.currentItem = event.Index
logger.debug(f"OnItemSelected: {self.currentItem}, {self.list.GetItemText(self.currentItem)}, {self.getColumnText(self.currentItem, 1)}")
# if self.currentItem == 10:
# logger.debug("OnItemSelected: Veto'd selection\n")
# # event.Veto() # doesn't work
# # this does
# self.list.SetItemState(10, 0, wx.LIST_STATE_SELECTED)
event.Skip()
def OnItemDeselected(self, event):
logger.debug('OnItemDeselected')
def OnItemActivated(self, event):
logger.debug('OnItemActivated')
self.currentItem = event.Index
logger.debug(f"OnItemActivated: {self.list.GetItemText(self.currentItem)} TopItem: {self.list.GetTopItem()}")
logger.debug(self.searchResult[self.currentItem])
fileName, relateName, fileDirPath = self.searchResult[self.currentItem]
captionName = fileName
window = EditorWindowManager().getWindow(self.GetTopLevelParent().Parent, os.path.join(fileDirPath, fileName))
# icon = self.list.OnGetItemImage(self.currentItem)
self.GetTopLevelParent().Parent._mgr.addTabByWindow(window=window, icon=None, name=f'{relateName}-{captionName}', captionName=captionName, tabDirection=5)
self.GetTopLevelParent().Destroy()
def OnItemDelete(self, event):
logger.debug('OnItemDelete')
def OnColClick(self, event):
logger.debug('OnColClick')
def OnColRightClick(self, event):
logger.debug('OnColRightClick')
def OnColBeginDrag(self, event):
logger.debug('OnColBeginDrag')
def OnColDragging(self, event):
logger.debug('OnColDragging')
def OnColEndDrag(self, event):
logger.debug('OnColEndDrag')
def OnBeginEdit(self, event):
logger.debug('OnBeginEdit')
def OnEndEdit(self, event):
logger.debug('OnEndEdit')
def OnDoubleClick(self, event):
logger.debug('OnDoubleClick')
def OnRightDown(self, event):
logger.debug('OnRightDown')
def OnRightClick(self, event):
logger.debug('OnRightClick')
def setImageList(self):
self.il = wx.ImageList(16, 16)
self.imageList = {
'_':['_', 'fileType_filter.png'],
'py':['py', 'python_module.png'],
'java':['java', 'jcu_obj.png'],
'md':['md', 'markdown.png'],
'txt':['txt', 'text.png'],
}
for imageExtension, item in self.imageList.items():
imageExtension, imageName = item[0], item[1]
item.append(self.il.Add(self.fileOperations.getImageBitmap(imageName=imageName)))
self.list.SetImageList(self.il, wx.IMAGE_LIST_SMALL)
def getExtension(self, fileName=None):
return fileName.split('.')[-1]
def loadData(self, items={}):
logger.debug('loadData')
self.list.ClearAll()
self.list.InsertColumn(0, "Name")
self.list.InsertColumn(1, "Path")
self.searchResult = items
# items = self.searchResult.items()
for key, data in items.items():
index = self.list.InsertItem(self.list.GetItemCount(), data[0], self.getImageIndex(extention=self.getExtension(fileName=data[0])))
self.list.SetItem(index, 1, data[1])
# self.list.SetItem(index, 2, data[2])
self.list.SetItemData(index, key)
self.list.SetColumnWidth(0, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(1, wx.LIST_AUTOSIZE)
def clearData(self):
logger.debug('clearData')
self.list.ClearAll()
def getImageIndex(self, extention='txt'):
imageIndex = 0
try:
if self.imageList[extention]:
imageIndex = self.imageList[extention][2]
except:
pass
return imageIndex
class BookExplorerTreePanel(ExpansionState, TreeCtrl):
'''
Left navigation tree in preferences page
'''
def __init__(self, parent):
TreeCtrl.__init__(self,
parent,
style=wx.TR_HIDE_ROOT | wx.TR_DEFAULT_STYLE
| wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.BORDER_NONE)
self._il = None
self.BuildTreeImageList()
self.SetInitialSize((100, 80))
def AppendItem(self, parent, text, image=-1, wnd=None):
item = TreeCtrl.AppendItem(self, parent, text, image=image)
return item
def BuildTreeImageList(self):
if self._il:
self._il.Destroy()
self._il = None
self._il = wx.ImageList(16, 16)
self.SetImageList(self._il)
self.ImageList.RemoveAll()
self.iconsDictIndex = {}
count = 0
self.fileOperations = FileOperations()
imageIconsName = [
'preference.png', 'folderType_filter.png',
'eclipse_open_folder.png', 'fileType_filter.png', 'usb.png',
'stop.png', 'java.png', 'python_module.png', 'xml.png',
"other_view.png", 'console_view.png', 'register_view.png',
'debug_view.png', 'history_view.png', 'compare_view.png',
'breakpoint_view.png', 'watchlist_view.png', 'history_view.png',
'synch_synch.png', 'variable_view.png', 'internal_browser.png',
'reflog.png', 'staging.png', 'rebase_interactive.png',
'repo_rep.png', 'gitrepository.png', 'filenav_nav.png',
'welcome16.png', 'tasks_tsk.png', 'resource_persp.png',
'outline_co.png', 'folder_user.png'
]
for item in bookExplorerList:
imageIconsName.append(item[2])
for imageName in imageIconsName:
try:
self.ImageList.Add(
self.fileOperations.getImageBitmap(imageName=imageName))
self.iconsDictIndex[imageName] = count
count += 1
except Exception as e:
logger.error(e)
def GetItemIdentity(self, item):
return self.GetItemData(item)
def Freeze(self):
if 'wxMSW' in wx.PlatformInfo:
return super(BookExplorerTreePanel, self).Freeze()
def Thaw(self):
if 'wxMSW' in wx.PlatformInfo:
return super(BookExplorerTreePanel, self).Thaw()
class CreatingTableInfoToolbarPanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
self.fileOperations = FileOperations()
self.tabName = kw['tabName']
self.dataSourceTreeNode = kw['dataSourceTreeNode']
self.data = list()
self.sqlList = dict()
vBox = wx.BoxSizer(wx.VERTICAL)
logger.debug(kw)
####################################################################
# adding new rows to the list on click of add button
# self.newRows={}
####################################################################
# self.topResultToolbar = self.constructTopResultToolBar()
self.bottomResultToolbar = wx.StatusBar(self)
self.resultPanel, self.toolbar = self.getPanelByTabName(tableName=kw['tableName'], tabName=kw['tabName'])
# self.resultPanel = ResultPanel(self, data=None)
self.bottomResultToolbar.SetStatusText("some text")
# self.bottomResultToolbar = self.constructBottomResultToolBar()
# self.resultPanel = ResultDataGrid(self, data=self.getData())
# bottomResultToolbar = self.constructBottomResultToolBar()
####################################################################
vBox.Add(self.toolbar , 0, wx.EXPAND | wx.ALL, 0)
# vBox.Add(self.resultPanel , 1, wx.EXPAND | wx.ALL, 0)
vBox.Add(self.resultPanel , 1, wx.EXPAND | wx.ALL)
vBox.Add(self.bottomResultToolbar , 0, wx.EXPAND | wx.ALL, 0)
# vBox.Add(bottomResultToolbar , 0, wx.EXPAND | wx.ALL, 0)
sizer = wx.BoxSizer(wx.VERTICAL)
# sizer.Add(worksheetToolbar ,.9, wx.EXPAND | wx.ALL, 0)
sizer.Add(vBox, 1, wx.EXPAND , 0)
self.SetSizer(sizer)
def constructTopResultToolBar(self, tabName=None):
# create some toolbars
tb1 = aui.AuiToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize, agwStyle=aui.AUI_TB_DEFAULT_STYLE | aui.AUI_TB_OVERFLOW)
tb1.SetToolBitmapSize(wx.Size(42, 42))
if tabName == 'Data':
tools = [
(ID_SAVE_ROW, "Save", "save_to_database.png", 'Save (Ctrl+S)', self.onSave),
(),
(ID_REFRESH_ROW, "Result refresh", "resultset_refresh.png", 'Result refresh \tF5', self.onRefresh),
(ID_ADD_ROW, "Add a new row", "row_add.png", 'Add a new row', self.onAddRow),
(ID_DUPLICATE_ROW, "Duplicate selected row", "row_copy.png", 'Duplicate selected row', self.onDuplicateRow),
(ID_DELETE_ROW, "Delete selected row", "row_delete.png", 'Delete selected row', self.onDeleteRow),
]
for tool in tools:
if len(tool) == 0:
tb1.AddSeparator()
else:
logger.debug(tool)
toolItem = tb1.AddSimpleTool(tool[0], tool[1], self.fileOperations.getImageBitmap(imageName=tool[2]), short_help_string=tool[3])
if tool[4]:
self.Bind(wx.EVT_MENU, tool[4], id=tool[0])
# tb1.AddSimpleTool(ID_SAVE_ROW, "Save", fileOperations.getImageBitmap(imageName="save_to_database.png"), short_help_string='Save to database')
# tb1.AddSeparator()
#
# tb1.AddSimpleTool(ID_REFRESH_ROW, "Result refresh", fileOperations.getImageBitmap(imageName="resultset_refresh.png"), short_help_string='Refresh data')
# tb1.AddSimpleTool(ID_ADD_ROW, "Add a new row", fileOperations.getImageBitmap(imageName="row_add.png"), short_help_string='Add new row')
# tb1.AddSimpleTool(ID_DUPLICATE_ROW, "Duplicate current row", fileOperations.getImageBitmap(imageName="row_copy.png"), short_help_string='Duplicate current row')
# tb1.AddSimpleTool(ID_DELETE_ROW, "Delete current row", fileOperations.getImageBitmap(imageName="row_delete.png"), short_help_string='Delete current row')
# tb1.AddSeparator()
# tb1.AddTool(ID_RUN, "Pin", fileOperations.getImageBitmap(imageName="pin2_green.png"))
tb1.Realize()
return tb1
def onSave(self, event):
logger.debug('onSave')
# finding rows to be updated
originalData = self.resultPanel.getData()
for row in range(self.resultPanel.GetNumberRows()):
rowMatch = True
rowPresent = False
for col in range(self.resultPanel.GetNumberCols()):
newVal = self.resultPanel.GetCellValue(row, col)
if row + 1 in originalData:
rowPresent = True
originalValue = originalData[row + 1][col]
if '-______-NULL' == originalValue:
originalValue = originalValue.replace('-______-', '')
if str(originalValue) != newVal:
rowMatch = False
break
else:
rowPresent = False
if rowPresent and not rowMatch:
newData = [self.resultPanel.GetCellValue(row, col) for col in range(self.resultPanel.GetNumberCols())]
columnClauseForUpdate = self.getColumnClauseForUpdate(newData=newData)
whereClause = self.getWhereClause(originalData[row + 1])
sql = f"UPDATE '{self.dataSourceTreeNode.nodeLabel}' SET {columnClauseForUpdate} WHERE {whereClause} ;"
self.sqlList[row] = {
'sql':sql,
'dml':'UPDATE',
'tableName':self.dataSourceTreeNode.nodeLabel,
'columns':self.dataSourceTreeNode.sqlType.columns,
'newValues':newData,
'oldValues':originalData[row + 1]
}
elif not rowPresent:
newData = [self.resultPanel.GetCellValue(row, col) for col in range(self.resultPanel.GetNumberCols())]
self.sqlList.get(row)['values']=newData
db = ManageSqliteDatabase(connectionName=self.dataSourceTreeNode.dataSource.connectionName, databaseAbsolutePath=self.dataSourceTreeNode.dataSource.filePath)
for row, sqlListRow in self.sqlList.items():
sql = self.getSql(sqlListRow).get('sql')
db.executeText(sql)
self.sqlList = dict()
# # sqlText = self.generateSql()
# db = ManageSqliteDatabase(connectionName=self.dataSourceTreeNode.dataSource.connectionName, databaseAbsolutePath=self.dataSourceTreeNode.dataSource.filePath)
# # db.executeText(sqlText)
#
# originalData = self.resultPanel.getData()
# originalDataSet = set()
# for k, v in originalData.items():
# if k > 0:
# originalDataSet.add(tuple([str(x) for x in v]))
#
# newData = set()
#
# for row in range(self.resultPanel.GetNumberRows()):
# newRow = []
# for col in range(self.resultPanel.GetNumberCols()):
# val = self.resultPanel.GetCellValue(row, col)
# if self.resultPanel.GetCellTextColour(row, col) == wx.LIGHT_GREY and val in ('NULL', 'BLOB'):
# newRow.append(f'-______-{val}')
# else:
# newRow.append(self.resultPanel.GetCellValue(row, col))
# newData.add(tuple(newRow))
#
# sql = self.generateSql(oldDataSet=originalDataSet, newDataSet=newData)
# print(sql)
def onRefresh(self, event):
logger.debug('onRefresh')
self.sqlList = dict()
db = ManageSqliteDatabase(connectionName=self.dataSourceTreeNode.dataSource.connectionName, databaseAbsolutePath=self.dataSourceTreeNode.dataSource.filePath)
# result = db.sqlite_select(tableName="sqlite_master")
data = None
tableName = self.GetParent().GetParent().tableName
if tableName:
data = db.executeText(text=f"SELECT * FROM '{tableName}' LIMIT 500;")
if data:
logger.debug('setResultData count: %s', len(data.keys()))
self.resultPanel.addData(data)
self.resultPanel.Layout()
def onAddRow(self, event):
logger.debug('onAddRow')
logger.debug(self.resultPanel.GetNumberRows())
# self.newRows[self.resultPanel.GetNumberRows()+1]=list()
# data=self.resultPanel.getData()
columnsName = [column.name for column in self.dataSourceTreeNode.sqlType.columns]
values = 'null,' * len(columnsName)
values = values[:-1]
valuesList = values[:-1].split(',')
columns = "`,`".join(columnsName)
sql = f'''INSERT INTO '{self.dataSourceTreeNode.nodeLabel}' (`{columns}`) VALUES ({values});'''
# self.sqlList[self.resultPanel.GetNumberRows()] = sql
self.sqlList[self.resultPanel.GetNumberRows()] = {
'sql':sql,
'dml':'INSERT',
'tableName':self.dataSourceTreeNode.nodeLabel,
'columns':columns,
'values':valuesList
}
self.resultPanel.AppendRows(numRows=1, updateLabels=True)
# TODO : a logic for save insert, update , delete has to go here
def onDuplicateRow(self, event):
logger.debug('onDuplicateRow')
def onDeleteRow(self, event):
seletedRows = list(self.resultPanel.GetSelectedRows())
logger.debug(f'onDeleteRow: {seletedRows}')
seletedRows.sort(reverse=True)
originalData = self.resultPanel.getData()
for selectedRow in seletedRows:
if selectedRow in self.sqlList:
del self.sqlList[selectedRow]
elif selectedRow in originalData:
columnsName = [column.name for column in self.dataSourceTreeNode.sqlType.columns]
columns = "`,`".join(columnsName)
data = originalData[selectedRow + 1]
whereClause = self.getWhereClause(data)
sql = f"""DELETE FROM '{self.dataSourceTreeNode.nodeLabel}' WHERE {whereClause} ;"""
# self.sqlList[selectedRow] = sql
self.sqlList[selectedRow] = {
'sql':sql,
'dml':'DELETE',
'tableName':self.dataSourceTreeNode.nodeLabel,
'columns':columns,
'values':data
}
# self.newRows.append(list())
# if selectedRow+1 in self.newRows:
# del self.newRows[selectedRow+1]
self.resultPanel.DeleteRows(pos=selectedRow, numRows=1, updateLabels=True)
# self.resultPanel.DeleteRows(pos=0, numRows=numRows, updateLabels=True)
# self.resultPanel.dele
def getSql(self, sqlListRow):
sql=None
columnsName = [column.name for column in self.dataSourceTreeNode.sqlType.columns]
columns = "`,`".join(columnsName)
if sqlListRow.get('dml') == 'DELETE':
whereClause = self.getWhereClause(sqlListRow.get('values'))
sql = f"""DELETE FROM '{sqlListRow.get('tableName')}' WHERE {whereClause} ;"""
elif sqlListRow.get('dml') == 'INSERT':
# columns = "`,`".join(sqlListRow.get('columns'))
values="','".join(sqlListRow.get('values'))
sql = f'''INSERT INTO '{sqlListRow.get('tableName')}' (`{sqlListRow.get('columns')}`) VALUES ('{values}');'''
elif sqlListRow.get('dml') == 'UPDATE':
columnClauseForUpdate = self.getColumnClauseForUpdate(newData=sqlListRow.get('newValues'))
whereClause = self.getWhereClause(sqlListRow.get('oldValues'))
sql = f"UPDATE '{self.dataSourceTreeNode.nodeLabel}' SET {columnClauseForUpdate} WHERE {whereClause} ;"
sqlListRow['sql']=sql
return sqlListRow
def getColumnClauseForUpdate(self, newData=None):
columnClauseForUpdate = []
for idx, column in enumerate(self.dataSourceTreeNode.sqlType.columns):
dataStr = newData[idx]
if '-______-NULL' == dataStr:
dataStr = dataStr.replace('-______-', '')
if column.primaryKey != 1:
columnClauseForUpdate.append(f" `{column.name}` = {dataStr}")
columnClauseForUpdateStr = ",".join(columnClauseForUpdate)
return columnClauseForUpdateStr
def getWhereClause(self, data):
whereClasue = []
for idx, column in enumerate(self.dataSourceTreeNode.sqlType.columns):
dataStr = data[idx]
if '-______-NULL' == dataStr:
dataStr = dataStr.replace('-______-', '')
whereClasue.append(f" `{column.name}` is {dataStr}")
else:
whereClasue.append(f" `{column.name}`={dataStr}")
whereClasueStr = " AND".join(whereClasue)
return whereClasueStr
def generateSql(self, oldDataSet=None, newDataSet=None):
logger.debug('generateSql')
intersect = oldDataSet.intersection(newDataSet)
insertSqlData = newDataSet - oldDataSet
oldPKSet = set(self.getPrimaryKeyValue(oldDataSet))
newPKSet = set(self.getPrimaryKeyValue(newDataSet))
insertPKSet = set(self.getPrimaryKeyValue(insertSqlData))
updatePKSet = oldPKSet.intersection(insertPKSet)
columnsName = [column.name for column in self.dataSourceTreeNode.sqlType.columns]
columns = "','".join(columnsName)
updateSqlDataSet = set()
valuesList = list()
for insertSqlDataRow in insertSqlData:
if insertSqlDataRow[0] in updatePKSet:
updateSqlDataSet.add(insertSqlDataRow)
else:
valuesList.append("','".join(insertSqlDataRow))
sqlList = list()
for values in valuesList:
sqlList.append(f'''INSERT INTO '{self.dataSourceTreeNode.nodeLabel}' ('{columns}') VALUES ('{values}');''')
return '\n'.join(sqlList)
def getPrimaryKeyValue(self, oldDataSet):
return [str(oldData[0]) for oldData in oldDataSet]
def getPanelByTabName(self, tableName=None, tabName=None):
toolbar = self.constructTopResultToolBar()
resultPanel = wx.Panel()
tableData = None
sampleData = None
indexData = None
referencesData = None
triggersData = None
sqlData = None
db = None
try:
# selectedItemText, dbFilePath = self.findingConnectionName()
db = ManageSqliteDatabase(connectionName=self.dataSourceTreeNode.dataSource.connectionName, databaseAbsolutePath=self.dataSourceTreeNode.dataSource.filePath)
result = db.sqlite_select(tableName="sqlite_master")
for row in result:
# selection of table and table name
if row[0] == 'table' and row[1] == tableName:
tableData = {
0:("#", "Name", "Datatype", "PRIMARY KEY", "Nullable", "Unique", "Auto increment", "Default data", "Description")
}
indexData = None
sqlData = row[4]
except Exception as e:
logger.error(e, exc_info=True)
if tabName == 'Columns':
resultPanel = ResultDataGrid(self, data=None)
if tableName:
rows = db.executeText(f"pragma table_info('{tableName}');")
if rows:
rows[-1] = ['INTEGER', 'VARCHAR', 'VARCHAR', 'BOOLEAN', 'VARCHAR', 'BOOLEAN' ]
resultPanel.addData(rows)
elif tabName == 'Indexes':
resultPanel = ResultDataGrid(self, data=None)
resultPanel.addData(indexData)
elif tabName == 'Data':
toolbar = self.constructTopResultToolBar(tabName=tabName)
resultPanel = ResultDataGrid(self, data=None)
data = None
if tableName:
data = db.executeText(text=f"SELECT * FROM `{tableName}` LIMIT 500;")
if data:
logger.debug('setResultData count: %s', len(data.keys()))
# self.bottomResultToolbar.SetStatusText("Count: {}".format(str(len(data.keys()))))
resultPanel.addData(data)
resultPanel.Layout()
elif tabName == 'References':
resultPanel = ResultDataGrid(self, data=None)
resultPanel.addData(referencesData)
elif tabName == 'Triggers':
resultPanel = ResultDataGrid(self, data=None)
resultPanel.addData(triggersData)
elif tabName == 'Triggers':
resultPanel = ResultDataGrid(self, data=None)
resultPanel.addData(triggersData)
elif tabName == 'SQL':
resultPanel = SqlConsoleOutputPanel(self, data=None)
try:
resultPanel.text.SetText(sqlData)
except Exception as e:
logger.error(e, exc_info=True)
elif tabName == 'ER diagram':
resultPanel = wx.Panel()
return resultPanel, toolbar
def findingConnectionName(self):
'''
This method defines connection name based on selected connection in the tree.
@return: (connectionName, databaseAbsolutePath)
'''
##################################################################################
sqlExecuter = SQLExecuter(database='_opal.sqlite')
textCtrl = self.GetTopLevelParent()._ctrl
connectionName = textCtrl.GetValue()
databaseAbsolutePath = sqlExecuter.getDbFilePath(connectionName)
logger.debug("databaseAbsolutePath: %s", databaseAbsolutePath)
##################################################################################
return connectionName, databaseAbsolutePath
def __init__(self, parent, style=wx.TR_DEFAULT_STYLE | wx.BORDER_NONE):
super(WelcomePanel, self).__init__()
wx.Panel.__init__(self, parent, style=style)
if wx.PlatformInformation.Get().GetOperatingSystemIdName() in [
'Linux', 'Unix', 'OS/2'
]:
pass
elif wx.PlatformInformation.Get().GetOperatingSystemIdName() in [
'DOS', 'Windows'
]:
self.startWebHelp()
fileOperations = FileOperations()
self.current = "http://localhost:5000"
self.frame = self.GetTopLevelParent()
self.titleBase = self.frame.GetTitle()
sizer = wx.BoxSizer(wx.VERTICAL)
# btnSizer = wx.BoxSizer(wx.HORIZONTAL)
self.wv = webview.WebView.New(self)
self.Bind(webview.EVT_WEBVIEW_NAVIGATING, self.OnWebViewNavigating,
self.wv)
self.Bind(webview.EVT_WEBVIEW_NAVIGATED, self.OnWebViewNavigated,
self.wv)
self.Bind(webview.EVT_WEBVIEW_LOADED, self.OnWebViewLoaded, self.wv)
self.Bind(webview.EVT_WEBVIEW_TITLE_CHANGED,
self.OnWebViewTitleChanged, self.wv)
# create some toolbars
tb1 = aui.AuiToolBar(self,
-1,
wx.DefaultPosition,
wx.DefaultSize,
agwStyle=aui.AUI_TB_DEFAULT_STYLE
| aui.AUI_TB_OVERFLOW)
tb1.SetToolBitmapSize(wx.Size(16, 16))
backButtonId = wx.NewIdRef()
homeButtonId = wx.NewIdRef()
forwardButtonId = wx.NewIdRef()
stopButtonId = wx.NewIdRef()
refreshButtonId = wx.NewIdRef()
openButtonId = wx.NewIdRef()
tb1_back = wx.ArtProvider.GetBitmap(wx.ART_GO_BACK, wx.ART_OTHER,
wx.Size(16, 16))
backButton = tb1.AddSimpleTool(backButtonId,
"Back",
tb1_back,
short_help_string="Back")
self.Bind(wx.EVT_MENU, self.OnPrevPageButton, id=backButtonId)
self.Bind(wx.EVT_UPDATE_UI, self.OnCheckCanGoBack, backButton)
tb1_home = wx.ArtProvider.GetBitmap(wx.ART_GO_HOME, wx.ART_OTHER,
wx.Size(16, 16))
tb1.AddSimpleTool(homeButtonId,
"Start Page",
tb1_home,
short_help_string="Start page")
self.Bind(wx.EVT_MENU, self.OnHomeButton, id=homeButtonId)
tb1_forward = wx.ArtProvider.GetBitmap(wx.ART_GO_FORWARD, wx.ART_OTHER,
wx.Size(16, 16))
forwardButton = tb1.AddSimpleTool(forwardButtonId,
"Forword",
tb1_forward,
short_help_string="Forword")
self.Bind(wx.EVT_MENU, self.OnNextPageButton, id=forwardButtonId)
self.Bind(wx.EVT_UPDATE_UI, self.OnCheckCanGoForward, forwardButton)
tb1_stop = wx.ArtProvider.GetBitmap(wx.ART_ERROR, wx.ART_OTHER,
wx.Size(16, 16))
tb1.AddSimpleTool(stopButtonId,
"Stop",
tb1_stop,
short_help_string="Stop")
self.Bind(wx.EVT_MENU, self.OnStopButton, id=stopButtonId)
tb1_refresh = wx.ArtProvider.GetBitmap(wx.ART_REDO, wx.ART_OTHER,
wx.Size(16, 16))
tb1.AddSimpleTool(refreshButtonId,
"Refresh",
tb1_refresh,
short_help_string="Refresh")
self.Bind(wx.EVT_MENU, self.OnRefreshPageButton, id=refreshButtonId)
self.location = wx.ComboBox(tb1,
-1,
"",
size=(400, -1),
style=wx.CB_DROPDOWN | wx.TE_PROCESS_ENTER)
self.location.AppendItems([
"http://localhost:5000", 'http://wxPython.org',
'http://wxwidgets.org', 'http://google.com'
])
for url in [
"http://localhost:5000", 'http://wxPython.org',
'http://wxwidgets.org', 'http://google.com'
]:
item = webview.WebViewHistoryItem(url, url)
# self.wv.LoadHistoryItem(item)
self.Bind(wx.EVT_COMBOBOX, self.OnLocationSelect, self.location)
self.location.Bind(wx.EVT_TEXT_ENTER, self.OnLocationEnter)
tb1.AddControl(self.location, label="Location: ")
# tb1_open = wx.ArtProvider.GetBitmap(wx.ART_TICK_MARK, wx.ART_OTHER, wx.Size(16, 16))
tb1.AddSimpleTool(
openButtonId,
"Open",
bitmap=fileOperations.getImageBitmap(imageName="webinar.png"),
short_help_string="Open")
self.Bind(wx.EVT_MENU, self.OnOpenButton, id=openButtonId)
tb1.Realize()
# sizer.Add(btnSizer, 0, wx.EXPAND)
sizer.Add(tb1, 0, wx.EXPAND)
sizer.Add(self.wv, 1, wx.EXPAND | wx.ALL, 0)
self.wv.LoadURL(self.current)
# logger.debug("---------------------------------"+ os.getcwd())
# htmlData=FileOperations().readFile(filePath='./html/welcome.html')
# logger.debug(htmlData)
#
# self.wv.SetPage(htmlData,"http://localhost:5000")
self.SetSizer(sizer)
class PropertiesFrame(wx.Frame):
def __init__(self, parent, title=None, size=(970, 720), depth=None, dataSource=None):
wx.Frame.__init__(self, parent, -1, title, size=size,
style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
self.fileOperations = FileOperations()
icon = wx.Icon()
icon.CopyFromBitmap(self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
# self.connectionName = connectionName
self.SetMinSize((640, 480))
####################################################################
'''
Footer section
'''
vBox = wx.BoxSizer(wx.VERTICAL)
self.buttonPanel = CreateButtonPanel(self)
####################################################################
self.splitter = wx.SplitterWindow(self, -1, style=wx.SP_3DBORDER)
self.splitter.SetMinimumPaneSize(20)
self.createLeftPropertiesTreePanel = CreateLeftPropertiesTreePanel(self.splitter)
self.rightPanel = RightPanel(self.splitter, name='Resource', dataSource=dataSource)
# self.resultDataGrid = ResultDataGrid(self.splitter)
self.splitter.SplitVertically(self.createLeftPropertiesTreePanel, self.rightPanel, sashPosition=210)
logger.info(self.splitter.GetDefaultSashSize())
####################################################################
# sizer.Add(self.createImportingCsvPanel, 1, wx.EXPAND)
# sizer.Add(self.resultDataGrid, 1, wx.EXPAND)
vBox.Add(self.splitter, 1, wx.EXPAND | wx.ALL)
vBox.Add(self.buttonPanel, 0, wx.EXPAND | wx.ALL)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(vBox, 1, wx.EXPAND , 0)
self.SetSizer(sizer)
# self.creatingToolbar()
self.Center()
self.BindEvents()
self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
# self.createStatusBar()
self.Show(True)
def OnKeyUP(self, event):
logger.info("KEY UP!")
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
def OnCloseFrame(self, event):
self.Destroy()
def OnSize(self, event):
hsize = event.GetSize()
logger.debug(hsize)
def BindEvents(self):
# self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
def createStatusBar(self):
logger.info('createStatusBar')
self.statusbar = self.CreateStatusBar(2, wx.STB_SIZEGRIP)
self.statusbar.SetStatusWidths([-2, -3])
# self.statusbar.SetStatusText(self.getCurrentCursorPosition(), 0)
self.statusbar.SetStatusText("Welcome {}".format(""), 1)
class CreatingTreePanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
self.fileOperations = FileOperations()
self.connDict = dict()
vBox = wx.BoxSizer(wx.VERTICAL)
####################################################################
self.sqlExecuter = SQLExecuter()
self._treeList = self.sqlExecuter.getObject()
self.treeMap = {}
self.searchItems = {}
self.tree = DatabaseNavigationTree(self)
self.filter = wx.SearchCtrl(self, style=wx.TE_PROCESS_ENTER)
self.filter.SetDescriptiveText("Type filter table name")
self.filter.ShowCancelButton(True)
self.filter.Bind(wx.EVT_TEXT, self.recreateTree)
self.filter.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN, lambda e: self.filter.SetValue(''))
self.filter.Bind(wx.EVT_TEXT_ENTER, self.OnSearch)
self.recreateTree()
# add drop target
self.SetDropTarget(MyFileDropTarget(self))
# self.tree.SetExpansionState(self.expansionState)
self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded)
self.tree.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed)
self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)
self.tree.Bind(wx.EVT_LEFT_DCLICK, self.OnTreeDoubleclick)
self.tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.onTreeItemActivated)
self.tree.Bind(wx.EVT_TREE_KEY_DOWN, self.onTreeKeyDown)
self.tree.Bind(wx.EVT_TREE_BEGIN_DRAG, self.onTreeBeginDrag)
self.tree.Bind(wx.EVT_RIGHT_DOWN, self.OnTreeRightDown)
self.tree.Bind(wx.EVT_RIGHT_UP, self.OnTreeRightUp)
# self.tree.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown, self)
####################################################################
vBox.Add(self.filter , 0, wx.EXPAND | wx.ALL)
vBox.Add(self.tree , 1, wx.EXPAND | wx.ALL)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(vBox, 1, wx.EXPAND , 0)
self.SetSizer(sizer)
def OnSearch(self, event=None):
value = self.filter.GetValue()
if not value:
self.recreateTree()
return
wx.BeginBusyCursor()
try:
for category, items in self._treeList[1]:
self.searchItems[category] = []
for childItem in items:
# if SearchDemo(childItem, value):
self.searchItems[category].append(childItem)
except Exception as e:
logger.error(e, exc_info=True)
wx.EndBusyCursor()
self.recreateTree()
#---------------------------------------------
def recreateTree(self, evt=None):
# Catch the search type (name or content)
# searchMenu = self.filter.GetMenu().GetMenuItems()
# fullSearch = searchMenu[1].IsChecked()
fullSearch = False
if evt:
if fullSearch:
# Do not`scan all the demo files for every char
# the user input, use wx.EVT_TEXT_ENTER instead
return
self.createDefaultNode()
# self.tree.Expand(self.root)
self.tree.Thaw()
self.searchItems = {}
#---------------------------------------------
def createDefaultNode(self):
logger.debug("TreePanel.createDefaultNode")
sqlExecuter = SQLExecuter()
dbList = sqlExecuter.getListDatabase()
fullSearch = False
expansionState = self.tree.GetExpansionState()
current = None
item = self.tree.GetSelection()
if item:
prnt = self.tree.GetItemParent(item)
if prnt:
current = (self.tree.GetItemText(item), self.tree.GetItemText(prnt))
self.tree.Freeze()
self.tree.DeleteAllItems()
self.root = self.tree.AddRoot("Connections")
self.tree.SetItemImage(self.root, 0)
data = dict()
data['depth'] = 0
self.tree.SetItemData(self.root, data)
treeFont = self.tree.GetFont()
catFont = self.tree.GetFont()
# The native treectrl on MSW has a bug where it doesn't draw
# all of the text for an item if the font is larger than the
# default. It seems to be clipping the item's label as if it
# was the size of the same label in the default font.
if 'wxMSW' not in wx.PlatformInfo:
treeFont.SetPointSize(treeFont.GetPointSize() + 2)
treeFont.SetWeight(wx.BOLD)
catFont.SetWeight(wx.BOLD)
self.tree.SetItemFont(self.root, treeFont)
firstChild = None
selectItem = None
filter = self.filter.GetValue()
count = 0
for db in dbList:
data = dict()
data['depth'] = 1
data['connection_name'] = db[1]
data['db_file_path'] = db[2]
if db[3] == 3:
image = 17
elif db[3] == 1:
image = 16
# elif db[3]==1:
# image=16
# Appending connections
item=self.addNode(targetNode=self.root, nodeLabel=db[1], pydata=data, image=image)
# self.connDict[db[1]]['itemId']=item
if db[1] in self.connDict.keys():
self.getNodeOnOpenConnection(selectedItemId=item)
# for key, value in self.connDict.items():
# if value['isConnected']:
# logger.debug("{}:{}".format(key, value))
self.tree.Expand(self.root)
if firstChild:
self.tree.Expand(firstChild)
# if filter:
# self.tree.ExpandAll()
if expansionState:
self.tree.SetExpansionState(expansionState)
if selectItem:
self.skipLoad = True
self.tree.SelectItem(selectItem)
self.skipLoad = False
def addNode(self, targetNode=None, nodeLabel='label', pydata=None, image=16):
nodeCreated = self.tree.AppendItem(targetNode, nodeLabel, image=image)
self.tree.SetItemFont(nodeCreated, self.tree.GetFont())
self.tree.SetItemData(nodeCreated, pydata)
return nodeCreated
def deleteChildren(self, itemId):
self.tree.DeleteChildren(itemId)
#---------------------------------------------
#---------------------------------------------
def OnItemExpanded(self, event):
item = event.GetItem()
logger.debug("OnItemExpanded: %s" % self.tree.GetItemText(item))
event.Skip()
#---------------------------------------------
def OnItemCollapsed(self, event):
item = event.GetItem()
# logger.debug("OnItemCollapsed: %s" % self.tree.GetItemText(item))
event.Skip()
#---------------------------------------------
def onTreeBeginDrag(self, event):
logger.debug('onTreeBeginDrag')
event.Skip()
def onTreeItemActivated(self, event):
logger.debug('onTreeItemActivated')
self.onConnectDb(event)
def onTreeKeyDown(self, event):
logger.debug('onTreeKeyDown')
keypress = self.GetKeyPress(event)
keycode = event.GetKeyCode()
keyname = keyMap.get(keycode, None)
logger.debug('onTreeKeyDown keycode: %s keyname:%s keypress: %s', keycode, keyname, keypress)
logger.debug(keypress == 'WXK_F2')
if keypress == 'Ctrl+C':
self.onTreeCopy(event)
elif keypress == 'WXK_F2':
self.onF2KeyPress(event)
elif keypress == 'WXK_DELETE':
self.onDeleteKeyPress(event)
event.Skip()
def GetKeyPress(self, evt):
keycode = evt.GetKeyCode()
keyname = keyMap.get(keycode, None)
modifiers = ""
for mod, ch in ((evt.GetKeyEvent().ControlDown(), 'Ctrl+'),
(evt.GetKeyEvent().AltDown(), 'Alt+'),
(evt.GetKeyEvent().ShiftDown(), 'Shift+'),
(evt.GetKeyEvent().MetaDown(), 'Meta+')):
if mod:
modifiers += ch
if keyname is None:
if 27 < keycode < 256:
keyname = chr(keycode)
else:
keyname = "(%s)unknown" % keycode
return modifiers + keyname
#----------------------------------------------------------------------
def onDeleteKeyPress(self, event):
try:
logger.debug(self.tree.GetItemData(self.tree.GetSelection()))
depth = self.tree.GetItemData(self.tree.GetSelection())['depth']
if depth == 1:
self.onDeleteConnection(event)
elif depth == 3:
logger.debug("TODO delete table")
self.onDeleteTable(event)
elif depth == 5:
logger.debug("TODO delete column")
except Exception as e:
logger.error(e, exc_info=True)
#----------------------------------------------------------------------
def onF2KeyPress(self, event):
try:
logger.debug(self.tree.GetItemData(self.tree.GetSelection()))
depth = self.tree.GetItemData(self.tree.GetSelection())['depth']
if depth == 3:
self.onRenameTable(event)
elif depth == 5:
self.onRenameColumn(event)
except Exception as e:
logger.error(e, exc_info=True)
def onTreeCopy(self, event):
""""""
self.dataObj = wx.TextDataObject()
self.dataObj.SetText(self.tree.GetItemText(self.tree.GetSelection()))
if not wx.TheClipboard.IsOpened(): # may crash, otherwise
wx.TheClipboard.Open()
try:
with wx.Clipboard.Get() as clipboard:
clipboard.SetData(self.dataObj)
except TypeError:
wx.MessageBox("Unable to open the clipboard", "Error")
def OnTreeDoubleclick(self, event):
logger.info("OnTreeDoubleclick")
pt = event.GetPosition();
item, flags = self.tree.HitTest(pt)
data = self.tree.GetItemData(item)
rightClickDepth = data['depth']
logger.info("Depth: {}".format(data['depth']))
if rightClickDepth == 1:
self.onConnectDb(event)
if rightClickDepth == 3:
# Open a new tab in SQL execution Pane. It is for table info.
# TODO
tableName = self.tree.GetItemText(item)
self.openWorksheet(sheetName=tableName)
if self.tree.IsExpanded(item):
self.tree.Collapse(item)
else:
self.tree.Expand(item)
def OnTreeLeftDown(self, event):
# reset the overview text if the tree item is clicked on again
pt = event.GetPosition();
item, flags = self.tree.HitTest(pt)
if item and item == self.tree.GetSelection():
logger.debug(self.tree.GetItemText(item) + " Overview")
event.Skip()
#---------------------------------------------
def OnSelChanged(self, event):
logger.debug('OnSelChanged')
pass
#---------------------------------------------
def OnTreeRightDown(self, event):
pt = event.GetPosition()
item, flags = self.tree.HitTest(pt)
if item:
self.tree.item = item
self.tree.item
logger.debug("OnRightClick: %s, %s, %s" % (self.tree.GetItemText(item), type(item), item.__class__) + "\n")
self.tree.SelectItem(item)
if self.tree.GetItemText(self.tree.item) != 'Connections':
logger.debug('parent %s', self.tree.GetItemText(self.tree.GetItemParent(self.tree.item)))
#---------------------------------------------
def OnTreeRightUp(self, event):
event.Skip
item = self.tree.item
if not item:
event.Skip()
return
logger.debug('OnTreeRightUp')
menu = wx.Menu()
data = self.tree.GetItemData(item)
rightClickDepth = data['depth']
if rightClickDepth == 0:
rootNewConnection = menu.Append(ID_ROOT_NEW_CONNECTION, "New connection ")
refreshBmp = wx.MenuItem(menu, ID_ROOT_REFERESH, "&Refresh")
refreshBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="database_refresh.png")))
rootRefresh = menu.Append(refreshBmp)
self.Bind(wx.EVT_MENU, self.onRootRefresh, rootRefresh)
self.Bind(wx.EVT_MENU, self.onRootNewConnection, rootNewConnection)
elif rightClickDepth == 1:
if data['connection_name'] in self.connDict and \
self.connDict[data['connection_name']]['isConnected']:
item1 = menu.Append(ID_DISCONNECT_DB, "Disconnect")
self.Bind(wx.EVT_MENU, self.onDisconnectDb, item1)
else:
item2 = menu.Append(ID_CONNECT_DB, "Connect")
self.Bind(wx.EVT_MENU, self.onConnectDb, item2)
sqlEditorBmp = wx.MenuItem(menu, ID_newWorksheet, "SQL Editor in new Tab")
sqlEditorBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="script.png")))
item3 = menu.Append(sqlEditorBmp)
infoMenuItem = wx.MenuItem(menu, ID_CONNECTION_PROPERTIES, "Properties")
infoBmp = wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_MENU, (16, 16))
infoMenuItem.SetBitmap(infoBmp)
item4 = menu.Append(infoMenuItem)
importBmp = wx.MenuItem(menu, ID_IMPORT, "&Import CSV / Excel")
importBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="import.png")))
importMenu = menu.Append(importBmp)
refreshBmp = wx.MenuItem(menu, wx.ID_REFRESH, "&Refresh")
refreshBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="database_refresh.png")))
item5 = menu.Append(refreshBmp)
# item6 = menu.Append(wx.ID_ANY, "Properties")
menu.AppendSeparator()
# item7 = wx.MenuItem(menu, wx.ID_ANY, "&Smile!\tCtrl+S", "This one has an icon")
# item7.SetBitmap(wx.Bitmap(os.path.abspath(os.path.join(path, "index.png"))))
# menu.AppendItem(item7)
deleteMenuItem = wx.MenuItem(menu, wx.ID_DELETE, "Delete reference \t Delete")
delBmp = wx.ArtProvider.GetBitmap(wx.ART_DELETE, wx.ART_MENU, (16, 16))
deleteMenuItem.SetBitmap(delBmp)
delMenu = menu.Append(deleteMenuItem)
deleteWithDatabaseMenuItem = wx.MenuItem(menu, ID_deleteWithDatabase, "Delete with database \t Shift + Delete")
delBmp = wx.ArtProvider.GetBitmap(wx.ART_DELETE, wx.ART_MENU, (16, 16))
deleteWithDatabaseMenuItem.SetBitmap(delBmp)
deleteWithDatabaseMenu = menu.Append(deleteWithDatabaseMenuItem)
# self.Bind(wx.EVT_MENU, self.OnItemBackground, item1)
self.Bind(wx.EVT_MENU, self.onOpenSqlEditorTab, item3)
self.Bind(wx.EVT_MENU, self.onProperties, item4)
self.Bind(wx.EVT_MENU, self.onImport, importMenu)
self.Bind(wx.EVT_MENU, self.onRefresh, item5)
# self.Bind(wx.EVT_MENU, self.onEditConnection, item6)
self.Bind(wx.EVT_MENU, self.onDeleteConnection, delMenu)
self.Bind(wx.EVT_MENU, self.onDeleteWithDatabaseTable, deleteWithDatabaseMenu)
# self.Bind(ID_CONNECTION_PROPERTIES, self.onConnectionProperties, deleteWithDatabaseMenu)
elif rightClickDepth == 2:
if 'table' in self.tree.GetItemText(item):
newTableBmp = wx.MenuItem(menu, wx.ID_ANY, "Create new table")
newTableBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="table_add.png")))
newTableItem = menu.Append(newTableBmp)
# newTableItem = menu.Append(wx.ID_ANY, "Create new table")
erDiagramItem = menu.Append(wx.ID_ANY, "Create ER diagram")
refreshTableItem = menu.Append(wx.ID_ANY, "Refresh \tF5")
self.Bind(wx.EVT_MENU, self.onNewTable, newTableItem)
self.Bind(wx.EVT_MENU, self.onCreateErDiagramItem, erDiagramItem)
self.Bind(wx.EVT_MENU, self.onRefreshTable, refreshTableItem)
if 'view' in self.tree.GetItemText(item):
newViewItem = menu.Append(wx.ID_ANY, "Create new view")
item2 = menu.Append(wx.ID_ANY, "Refresh \tF5")
self.Bind(wx.EVT_MENU, self.onNewView, newViewItem)
if 'index' in self.tree.GetItemText(item) :
newIndexItem = menu.Append(wx.ID_ANY, "Create new index")
item2 = menu.Append(wx.ID_ANY, "Refresh \tF5")
self.Bind(wx.EVT_MENU, self.onNewIndex, newIndexItem)
elif 'Columns' in self.tree.GetItemText(item) :
newColumnItem = menu.Append(wx.ID_ANY, "Add new column")
self.Bind(wx.EVT_MENU, self.onNewColumn, newColumnItem)
elif 'table' in self.tree.GetItemText(self.tree.GetItemParent(self.tree.item)) :
logger.debug(self.tree.GetItemText(item))
editTableBmp = wx.MenuItem(menu, wx.ID_ANY, "Edit table")
editTableBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="table_edit.png")))
editTableItem = menu.Append(editTableBmp)
# editTableItem = menu.Append(wx.ID_ANY, "Edit table ")
renameTableItem = menu.Append(wx.ID_ANY, "Rename Table ")
copyCreateTableItem = menu.Append(wx.ID_ANY, "Copy create table statement")
deleteTableBmp = wx.MenuItem(menu, wx.ID_ANY, "&Delete table ")
deleteTableBmp.SetBitmap(wx.Bitmap(self.fileOperations.getImageBitmap(imageName="table_delete.png")))
deleteTableItem = menu.Append(deleteTableBmp)
self.Bind(wx.EVT_MENU, self.onDeleteTable, deleteTableItem)
self.Bind(wx.EVT_MENU, self.onEditTable, editTableItem)
self.Bind(wx.EVT_MENU, self.onRenameTable, renameTableItem)
self.Bind(wx.EVT_MENU, self.onCopyCreateTableStatement, copyCreateTableItem)
elif 'Column' in self.tree.GetItemText(self.tree.GetItemParent(self.tree.item)) :
logger.debug(self.tree.GetItemText(item))
item1 = menu.Append(wx.ID_ANY, "Edit column")
renameColumnItem = menu.Append(wx.ID_ANY, "Rename Column ")
# item1 = menu.Append(wx.ID_ANY, "Create new column")
# self.Bind(wx.EVT_MENU, self.OnItemBackground, item1)
self.Bind(wx.EVT_MENU, self.onRenameColumn, renameColumnItem)
self.PopupMenu(menu)
menu.Destroy()
def onDeleteTable(self, event):
logger.debug('onDeleteTable')
try:
# data = self.tree.GetPyData(self.tree.GetSelection()).Data
depth = self.tree.GetItemData(self.tree.GetSelection())['depth']
##################################################################################
sqlExecuter = SQLExecuter(database='_opal.sqlite')
textCtrl = self.GetTopLevelParent()._ctrl
selectedItemText = textCtrl.GetValue()
databaseAbsolutePath = sqlExecuter.getDbFilePath(selectedItemText)
logger.debug("dbFilePath: %s", databaseAbsolutePath)
##################################################################################
# connectionName = data['connection_name']
# databaseAbsolutePath = data['db_file_path']
if os.path.isfile(databaseAbsolutePath) and depth == 3:
text = "DROP TABLE '{}'".format(self.tree.GetItemText(self.tree.GetSelection()))
dbObjects = ManageSqliteDatabase(connectionName=selectedItemText , databaseAbsolutePath=databaseAbsolutePath).executeText(text)
self.recreateTree(event)
except Exception as e:
logger.error(e, exc_info=True)
def onRefreshTable(self, event):
logger.debug('onRefreshTable')
def onRootRefresh(self, event):
logger.debug('onRootRefresh')
self.recreateTree(event)
def onRootNewConnection(self, event):
logger.debug('onRootNewConnection')
CreateNewConncetionWixard(self).createWizard()
# Refresh tree.
def onCopyCreateTableStatement(self, event):
logger.debug('onCopyCreateTableStatement')
def onRenameColumn(self, event):
logger.debug('onRenameColumn')
initialColumnName = self.tree.GetItemText(self.tree.GetSelection())
dlg = wx.TextEntryDialog(self, 'Rename column ' + initialColumnName, 'Rename column ' + initialColumnName, 'Python')
dlg.SetValue(self.tree.GetItemText(self.tree.GetSelection()))
if dlg.ShowModal() == wx.ID_OK:
logger.info('You entered: %s\n', dlg.GetValue())
if dlg.GetValue() != self.tree.GetItemText(self.tree.GetSelection()):
logger.info('update table execute')
data = self.tree.GetItemData(self.tree.GetSelection())
connectionName = data['connection_name']
databaseAbsolutePath = data['db_file_path']
if os.path.isfile(databaseAbsolutePath):
'''
First you rename the old table:
ALTER TABLE orig_table_name RENAME TO tmp_table_name;
Then create the new table, based on the old table but with the updated column name:
Then copy the contents across from the original table.
'''
logger.debug("TODO logic for rename column goes here.")
# dbObjects = ManageSqliteDatabase(connectionName=connectionName , databaseAbsolutePath=databaseAbsolutePath).executeText(text)
dlg.Destroy()
# def onDeleteConnection(self, event):
# logger.debug('onDeleteConnection')
# logger.debug("TODO delete connection name")
# data = self.tree.GetItemData(self.tree.GetSelection())
# connectionName = data['connection_name']
# databaseAbsolutePath = data['db_file_path']
# if os.path.isfile(databaseAbsolutePath):
# sqlExecuter = SQLExecuter()
# text="DELETE FROM conns WHERE {} "
# sqlExecuter.executeText(text)
def onRenameTable(self, event):
logger.debug('onRenameTable')
oldTableName = initialTableName = self.tree.GetItemText(self.tree.GetSelection())
dlg = wx.TextEntryDialog(self, 'Rename table {} to'.format(initialTableName), 'Rename table {} '.format(initialTableName), 'Python')
dlg.SetValue(self.tree.GetItemText(self.tree.GetSelection()))
if dlg.ShowModal() == wx.ID_OK:
logger.info('You entered: %s\n', dlg.GetValue())
if dlg.GetValue() != self.tree.GetItemText(self.tree.GetSelection()):
logger.info('update table execute')
newTableName = dlg.GetValue()
data = self.tree.GetItemData(self.tree.GetSelection())
connectionName = data['connection_name']
databaseAbsolutePath = data['db_file_path']
if os.path.isfile(databaseAbsolutePath):
'''
First you rename the old table:
'''
logger.debug("TODO logic to rename table should go here.")
# dropTableSql="DROP TABLE '{}'".format()
alterTableSql = "ALTER TABLE '{}' RENAME TO {}".format(oldTableName, newTableName)
db = ManageSqliteDatabase(connectionName=connectionName , databaseAbsolutePath=databaseAbsolutePath)
try:
db.executeText(alterTableSql)
except Exception as e:
self.consoleOutputLog(e)
self.recreateTree(event)
dlg.Destroy()
def consoleOutputLog(self, exception=None):
now = datetime.datetime.now()
strftime = now.strftime("%Y-%m-%d %H:%M:%S")
newline = "\n"
if self.GetTopLevelParent()._mgr.GetPane("consoleOutput").window.text.Value.strip() == "":
newline = ""
self.GetTopLevelParent()._mgr.GetPane("consoleOutput").window.text.AppendText("{}{} {}".format(newline, strftime, exception))
def onEditTable(self, event):
logger.debug('onEditTable')
def OnItemBackground(self, event):
logger.debug('OnItemBackground')
try:
pt = event.GetPosition();
item, flags = self.tree.HitTest(pt)
self.tree.EditLabel(item)
except Exception as e:
logger.error(e, exc_info=True)
def onConnectDb(self, event):
logger.debug('onConnectDb')
# item = self.tree.GetSelection()
try:
if self.tree.GetItemText(self.tree.GetSelection()) not in self.connDict.keys():
selectedItemId = self.tree.GetSelection()
if self.getNodeOnOpenConnection(selectedItemId=selectedItemId):
# self.addNode(targetNode=, nodeLabel='got conncted',pydata=data, image=16)
# Todo change icon to enable
selectedItemText = self.tree.GetItemText(self.tree.GetSelection())
self.setAutoCompleteText(selectedItemText)
pub.sendMessage('onNewWorksheet', event=event)
# self.openWorksheet(sheetName="Worksheet")
self.connDict[self.tree.GetItemText(self.tree.GetSelection())] = {
'isConnected':True,
'data':self.tree.GetItemData(self.tree.GetSelection())
}
except Exception as e:
logger.error(e, exc_info=True)
def setAutoCompleteText(self, selectedItemText):
'''
This is to set autocomplete text as we connect to database
'''
logger.debug(selectedItemText)
if hasattr(self.GetTopLevelParent(), '_mgr'):
tb1 = self.GetTopLevelParent()._mgr.GetPane("viewToolbar").window
choice = self.GetTopLevelParent()._ctrl.GetChoices()
textCtrl = self.GetTopLevelParent()._ctrl
textCtrl.SetValue(selectedItemText)
# textCtrl.SetSelection(choice.index(selectedItemText))
textCtrl.SetInsertionPointEnd()
textCtrl.SetSelection(-1, -1)
textCtrl._showDropDown(False)
def onDisconnectDb(self, event):
logger.debug('onDisconnectDb')
del self.connDict[self.tree.GetItemText(self.tree.GetSelection())]
selectedItem = self.tree.GetSelection()
if selectedItem:
self.tree.DeleteChildren(selectedItem)
# Todo change icon to dissable
def onOpenSqlEditorTab(self, event):
logger.debug('onOpenSqlEditorTab')
# self.openWorksheet(sheetName="Worksheet")
pub.sendMessage('onNewWorksheet', event=event, extra1='onJavaPerspective')
def openWorksheet(self, sheetName="tableName"):
if hasattr(self.GetTopLevelParent(), '_mgr'):
tableInfo= CreatingTableInfoPanel(self, -1, style=wx.CLIP_CHILDREN |wx.BORDER_NONE, tableName=sheetName)
sqlExecutionTab = self.GetTopLevelParent()._mgr.addTabByWindow(window=tableInfo , imageName="script.png", captionName=sheetName, tabDirection=5)
# if sqlExecutionTab.window:
# sqlExecutionTab.window.addTab(name=sheetName)
def onProperties(self, event):
logger.debug('onProperties')
if event.Id==ID_CONNECTION_PROPERTIES:
logger.debug('onProperties')
def onImport(self, event=None):
logger.debug('onImport')
selectedItem = self.tree.GetSelection()
connectionName = self.tree.GetItemText(selectedItem)
frame = ImportingCsvExcelFrame(None, 'Import CSV Excel', connectionName)
frame.Show()
def onRefresh(self, event=None):
logger.debug('onRefresh')
'''
1. find current active connection.
2. refresh only that connection.
'''
##################################################################################
sqlExecuter = SQLExecuter(database='_opal.sqlite')
textCtrl = self.GetTopLevelParent()._ctrl
selectedItemText = textCtrl.GetValue()
dbFilePath = sqlExecuter.getDbFilePath(selectedItemText)
logger.debug("dbFilePath: %s", dbFilePath)
##################################################################################
# selectedItem = self.tree.GetSelection()
# if selectedItem:
# self.tree.DeleteChildren(selectedItem)
# self.getNodeOnOpenConnection(selectedItemId)
def onEditConnection(self, event):
logger.debug('onEditConnection')
def onDeleteWithDatabaseTable(self, event):
logger.debug('onDeleteWithDatabaseTable')
# self.onDeleteConnection(event)
##################################################################################
sqlExecuter = SQLExecuter(database='_opal.sqlite')
selectedItemId = self.tree.GetSelection()
selectedItemText = self.tree.GetItemText(self.tree.GetSelection())
dbFilePath = sqlExecuter.getDbFilePath(selectedItemText)
logger.debug("dbFilePath: %s", dbFilePath)
##################################################################################
fileOperations = FileOperations()
fileRemoved = fileOperations.removeFile(filename=dbFilePath)
if selectedItemText and fileRemoved:
self.sqlExecuter.removeConnctionRow(selectedItemText)
self.recreateTree()
def onDeleteConnection(self, event):
logger.debug('onDeleteConnection')
selectedItemId = self.tree.GetSelection()
selectedItemText = self.tree.GetItemText(self.tree.GetSelection())
logger.debug(selectedItemText)
if selectedItemText:
self.sqlExecuter.removeConnctionRow(selectedItemText)
self.recreateTree()
def onCreateErDiagramItem(self, event):
logger.debug('onCreateErDiagramItem')
##################################################################################
sqlExecuter = SQLExecuter(database='_opal.sqlite')
textCtrl = self.GetTopLevelParent()._ctrl
selectedItemText = textCtrl.GetValue()
dbFilePath = sqlExecuter.getDbFilePath(selectedItemText)
logger.debug("dbFilePath: %s", dbFilePath)
##################################################################################
depth = self.tree.GetItemData(self.tree.GetSelection())['depth']
if os.path.isfile(dbFilePath):
dbObjects = ManageSqliteDatabase(connectionName=selectedItemText , databaseAbsolutePath=dbFilePath).getObject()
createErDiagramFrame = CreateErDiagramFrame(None)
createErDiagramFrame.setDbObjects(dbObjects=dbObjects)
createErDiagramFrame.Show()
def onNewTable(self, event):
logger.debug('onNewTable')
item = self.tree.item
connectionName = self.tree.GetItemText(self.tree.GetItemParent(item))
newTableName = SQLUtils().definingTableName(connectionName)
tableFrame = CreatingTableFrame(None, 'Table creation', connectionName, newTableName)
# frame = CreateTableFrame(None, 'table creation')
# tableDict = dict()
# tableFrame.setData(tableDict)
tableFrame.Show()
# app.MainLoop()
def onNewView(self, event):
logger.debug('onNewView')
# tableFrame = CreateTableFrame(None, 'Table creation')
def onNewColumn(self, event):
logger.debug('onNewColumn')
logger.debug("TODO add a new column")
def onNewIndex(self, event):
logger.debug('onNewIndex')
logger.debug("TODO add a new Index")
# tableFrame = CreateTableFrame(None, 'Table creation')
def getNodeOnOpenConnection(self, selectedItemId=None, data=None):
'''
This method will return database node on open connection
'''
isSuccessfullyConnected = False
logger.debug('getNodeOnOpenConnection')
if selectedItemId:
data = self.tree.GetItemData(selectedItemId)
connectionName = data['connection_name']
databaseAbsolutePath = data['db_file_path']
self.deleteChildren(selectedItemId)
if os.path.isfile(databaseAbsolutePath):
dbObjects = ManageSqliteDatabase(connectionName=connectionName , databaseAbsolutePath=databaseAbsolutePath).getObject()
isSuccessfullyConnected = True
for dbObject in dbObjects[1]:
for k0, v0 in dbObject.items():
logger.debug("k0 : %s, v0: %s", k0, v0)
data = dict()
data['depth'] = 2
data['connection_name'] = connectionName
data['db_file_path'] = databaseAbsolutePath
image = 2
nodeLabel = k0 + ' (' + str(len(v0)) + ')'
child0 = self.addNode(targetNode=selectedItemId, nodeLabel=nodeLabel, pydata=data, image=image)
if 'table' == k0 :
# setting image for 'table'
image = 4
elif 'index' == k0 :
# setting image for 'index'
image = 5
elif 'view' == k0 :
# setting image for 'view'
image = 6
# child = self.tree.AppendItem(selectedItemId, k0 + ' (' + str(len(items)) + ')', image=count)
for v00 in v0:
for k1, v1 in v00.items():
# Listing tables
data = dict()
data['depth'] = 3
data['connection_name'] = connectionName
data['db_file_path'] = databaseAbsolutePath
nodeLabel = k1
if k0 == 'table':
image = 4
child1 = self.addNode(targetNode=child0, nodeLabel=nodeLabel, pydata=data, image=image)
# logger.debug("k1 : %s, v1: %s", k1, v1)
if k0 == 'table':
data = dict()
data['depth'] = 4
data['connection_name'] = connectionName
data['db_file_path'] = databaseAbsolutePath
# setting image for 'Columns', 'Unique Keys', 'Foreign Keys', 'References'
image = 11
child1_1 = self.addNode(targetNode=child1, nodeLabel='Columns' + ' (' + str(len(v1)) + ')', pydata=data, image=image)
child1_2 = self.addNode(targetNode=child1, nodeLabel='Unique Keys', pydata=data, image=image)
child1_3 = self.addNode(targetNode=child1, nodeLabel='Foreign Keys', pydata=data, image=image)
child1_4 = self.addNode(targetNode=child1, nodeLabel='References', pydata=data, image=image)
for v2 in v1:
if k0 == 'table':
data = dict()
data['depth'] = 5
data['connection_name'] = connectionName
data['db_file_path'] = databaseAbsolutePath
# (cid integer, name text, type text, nn bit, dflt_value, pk bit)
nodeLabel = v2[1]
image = 18
if v2[5] == 1:
# setting primary key image
image = 9
elif v2[5] == 0 and v2[2] in ['INTEGER', 'INT']:
# setting INTEGER image
image = 7
elif v2[5] == 0 :
for datatype in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
if v2[2].lower().startswith(datatype.lower()):
# setting VARCHAR image
image = 18
break
child2 = self.addNode(targetNode=child1_1, nodeLabel=nodeLabel, pydata=data, image=image)
else:
updateStatus = "Unable to connect '" + databaseAbsolutePath + ".' No such file. "
self.consoleOutputLog(updateStatus)
font = self.GetTopLevelParent().statusbar.GetFont()
font.SetWeight(wx.BOLD)
self.GetTopLevelParent().statusbar.SetFont(font)
self.GetTopLevelParent().statusbar.SetForegroundColour(wx.RED)
self.GetTopLevelParent().statusbar.SetStatusText(updateStatus, 1)
logger.error(updateStatus)
return isSuccessfullyConnected
class OtherViewBaseTreePanel(ExpansionState, TreeCtrl):
'''
Left navigation tree in preferences page
'''
def __init__(self, parent):
TreeCtrl.__init__(self,
parent,
style=wx.TR_HIDE_ROOT | wx.TR_DEFAULT_STYLE
| wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.BORDER_NONE)
self._il = None
self.BuildTreeImageList()
# if USE_CUSTOMTREECTRL:
# self.SetSpacing(10)
# self.SetWindowStyle(self.GetWindowStyle() & ~wx.TR_LINES_AT_ROOT)
self.SetInitialSize((100, 80))
def AppendItem(self, parent, text, image=-1, wnd=None):
item = TreeCtrl.AppendItem(self, parent, text, image=image)
return item
def BuildTreeImageList(self):
# imgList = wx.ImageList(16, 16)
#
# for png in _demoPngs:
# imgList.Add(catalog[png].GetBitmap())
#
# # add the image for modified demos.
# imgList.Add(catalog["custom"].GetBitmap())
#
# self.AssignImageList(imgList)
if self._il:
self._il.Destroy()
self._il = None
self._il = wx.ImageList(16, 16)
self.SetImageList(self._il)
self.ImageList.RemoveAll()
self.iconsDictIndex = {}
count = 0
self.fileOperations = FileOperations()
for imageName in [
'preference.png',
'folder.png',
'folder_view.png',
'fileType_filter.png',
'usb.png',
'stop.png',
'java.png',
'python_module.png',
'xml.png',
"other_view.png",
'gitrepository.png',
'jperspective.png',
'javaee_perspective.png',
'python_perspective.png',
'database.png',
'resource_persp.png',
'debug_persp.png',
'jpa.png',
'web_perspective.png',
'javascript_perspective.png',
'plugin_perspecitve.png',
'svn_perspective.png',
'remote_perspective.png',
'browse_persp.png',
'perspective-planning.png',
'database_debug_perspective.png',
'java_type_hierarchy.png',
'xml_perspective.png',
'synch_synch.png',
]:
try:
self.ImageList.Add(
self.fileOperations.getImageBitmap(imageName=imageName))
self.iconsDictIndex[imageName] = count
count += 1
except Exception as e:
logger.error(imageName, e)
def GetItemIdentity(self, item):
return self.GetItemData(item)
def Freeze(self):
if 'wxMSW' in wx.PlatformInfo:
return super(OtherViewBaseTreePanel, self).Freeze()
def Thaw(self):
if 'wxMSW' in wx.PlatformInfo:
return super(OtherViewBaseTreePanel, self).Thaw()
class ThumbnailCtrlPaginationPanel(wx.Panel, WorkspaceHelper):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
WorkspaceHelper.__init__(self)
pub.subscribe(self.reloadingDatabase, 'reloadingDatabase')
vBox = wx.BoxSizer(wx.VERTICAL)
####################################################################
self.libraryPath = self.getLibraryPath()
self.fileDropTarget = FileDropTarget(self, libraryPath=self.libraryPath)
self.fileOperations = FileOperations()
self.search = wx.SearchCtrl(self, size=(200, -1), style=wx.TE_PROCESS_ENTER)
self.search.ShowSearchButton(1)
self.search.ShowCancelButton(1)
self.search.SetMenu(None)
self.search.Bind(wx.EVT_TEXT_ENTER, self.OnSearch)
self.search.Bind(wx.EVT_TEXT, self.OnSearch)
self.thumbnailCtrl = ThumbnailCtrl(self, -1, imagehandler=NativeImageHandler)
self.thumbnailCtrl.EnableToolTips(enable=True)
self.thumbnailCtrl.SetDropTarget(self.fileDropTarget)
# self.thumbnailCtrl.ShowDir(r'/home/vijay/Pictures')
# findingBook = FindingBook(libraryPath=r'/docs/new/library')
# books = findingBook.searchingBook(searchText='head')
self.page = Page()
self.loadingBook()
self.paginationBar = self.constructTopToolBar()
self.setPaginationBarStatus()
####################################################################
vBox.Add(self.search , 0, wx.EXPAND | wx.ALL)
vBox.Add(self.thumbnailCtrl , 1, wx.EXPAND | wx.ALL)
vBox.Add(self.paginationBar , 0, wx.EXPAND | wx.ALL, 0)
# vBox.Add(self.tree , 1, wx.EXPAND | wx.ALL)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(vBox, 1, wx.EXPAND , 0)
self.SetSizer(sizer)
@debounce(1)
def OnSearch(self, event):
logger.debug('onSearch')
self.page.searchText = self.search.GetValue()
self.loadingBook(searchText=self.search.GetValue())
self.updatePangnation()
def loadingBook(self, searchText=None):
books = None
totalBooks=0
count = 0
if self.libraryPath and os.path.exists(self.libraryPath):
findingBook = FindingBook(libraryPath=self.libraryPath)
if self.page.searchText:
books, count = findingBook.searchingBook(searchText=self.page.searchText, pageSize=self.page.pageSize, offset=self.page.pageSize * self.page.currentPage)
else:
books, count = findingBook.findAllBooks(pageSize=self.page.pageSize, offset=self.page.pageSize * self.page.currentPage)
totalBooks=findingBook.countAllBooks()
self.page.pageData = books
self.page.total = count
self.page.pages = int(self.page.total // self.page.pageSize) + 1
self.page.searchText = searchText
self.thumbnailCtrl.ShowBook(books)
self.updateStatusBar(text=f'found : {count} of {totalBooks}')
# update pagination toolbar status
# self.setPaginationBarStatus()
def updateStatusBar(self, text=None):
if text and str(type(self.GetTopLevelParent())) == "<class 'src.view.TheEclipseView.EclipseMainFrame'>":
self.GetTopLevelParent().SetStatusText(text, 0)
def setPaginationBarStatus(self):
logger.debug(f'setPaginationBarStatus:{self.page.pages}')
if self.page.pages == 1:
self.paginationBar.EnableTool(ID_FIRST_RESULT, False)
self.paginationBar.EnableTool(ID_PREVIOUS_RESULT, False)
self.paginationBar.EnableTool(ID_NEXT_RESULT, False)
self.paginationBar.EnableTool(ID_LAST_RESULT, False)
if self.page.pages > 1:
self.paginationBar.EnableTool(ID_FIRST_RESULT, False)
self.paginationBar.EnableTool(ID_PREVIOUS_RESULT, False)
self.paginationBar.EnableTool(ID_NEXT_RESULT, True)
self.paginationBar.EnableTool(ID_LAST_RESULT, True)
self.paginationBar.Realize()
def updatePangnation(self):
pageNumbers = [f'{1+pageNum}' for pageNum in range(self.page.pages)]
if hasattr(self, 'pageNumbersCountText'):
self.pageNumbersCountText.SetLabel(f"/{len(pageNumbers)}")
self.setPaginationBarStatus()
# if hasattr(self, 'pageNumberCtrl'):
# self.pageNumberCtrl.Set(pageNumbers)
# self.pageNumberCtrl.SetSelection(0)
def constructTopToolBar(self):
# create some toolbars
tb1 = aui.AuiToolBar(self, -1, wx.DefaultPosition, (10, 10), agwStyle=aui.AUI_TB_DEFAULT_STYLE | aui.AUI_TB_OVERFLOW)
# tb1.SetToolBitmapSize(wx.Size(16, 16))
# id, name, image, name, method, kind
pageSizeText = TransparentText(tb1, -1, "Page Size")
# tb1.AddControl(pageSizeText)
pageNumber = [f'{pageNum}' for pageNum in range(5, 101, 20)]
self.pageSizeCtrl = wx.Choice(tb1, 10, (-1, -1), (50, 25), pageNumber, style=0)
index = pageNumber.index(f'{self.page.pageSize}')
self.pageSizeCtrl.SetSelection(index)
pageNumbers = [f'{1+pageNum}' for pageNum in range(self.page.pages)]
self.pageNumberCtrl = wx.Choice(tb1, 11, (-1, -1), (50, 25), pageNumbers, style=0)
self.pageNumberCtrl.SetSelection(0)
self.pageNumbersCountText = TransparentText(tb1, -1, f"/{len(pageNumbers)}")
# tb1.AddControl(choice)
tools = [
('control', pageSizeText),
('control', self.pageSizeCtrl),
(ID_FIRST_RESULT, "First", "resultset_first.png", 'First', lambda e:self.onToolButtonClick(e), wx.ITEM_NORMAL),
(ID_PREVIOUS_RESULT, "Previous", "resultset_previous.png", 'Previous', lambda e:self.onToolButtonClick(e), wx.ITEM_NORMAL),
('control', self.pageNumberCtrl),
('control', self.pageNumbersCountText),
(ID_NEXT_RESULT, "Next", "resultset_next.png", 'Next', lambda e:self.onToolButtonClick(e), wx.ITEM_NORMAL),
(ID_LAST_RESULT, "Last", "resultset_last.png", 'Last', lambda e:self.onToolButtonClick(e), wx.ITEM_CHECK),
# (ID_REFRESH_ROW, "Result refresh", "resultset_refresh.png", 'Result refresh \tF5', self.onRefresh),
# (ID_ADD_ROW, "Add a new row", "row_add.png", 'Add a new row', self.onAddRow),
# (ID_DUPLICATE_ROW, "Duplicate selected row", "row_copy.png", 'Duplicate selected row', self.onDuplicateRow),
# (ID_DELETE_ROW, "Delete selected row", "row_delete.png", 'Delete selected row', self.onDeleteRow),
]
for tool in tools:
if len(tool) == 0:
tb1.AddSeparator()
elif len(tool) == 2:
tb1.AddControl(tool[1])
else:
logger.debug(tool)
toolItem = tb1.AddSimpleTool(tool[0], tool[1], self.fileOperations.getImageBitmap(imageName=tool[2]), kind=tool[5], short_help_string=tool[3])
if tool[4]:
self.Bind(wx.EVT_MENU, tool[4], id=tool[0])
# tb1.AddControl(choice)
self.Bind(wx.EVT_CHOICE, self.onPageNumberCtrl, self.pageNumberCtrl)
self.Bind(wx.EVT_CHOICE, self.onPageSizeCtrl, self.pageSizeCtrl)
tb1.Realize()
return tb1
def onPageNumberCtrl(self, event):
logger.debug('onPageNumberCtrl')
self.page.currentPage = int(event.GetString()) - 1
self.loadingBook()
def onPageSizeCtrl(self, event):
logger.debug('onPageSizeCtrl')
self.page.pageSize = int(event.GetString())
self.loadingBook()
if hasattr(self, 'pageNumberCtrl'):
pageNumbers = [f'{1+pageNum}' for pageNum in range(self.page.pages)]
self.pageNumberCtrl.Set(pageNumbers)
self.pageNumberCtrl.SetSelection(0)
if hasattr(self, 'pageNumbersCountText'):
self.pageNumbersCountText.SetLabel(f"/{len(pageNumbers)}")
self.setPaginationBarStatus()
def onToolButtonClick(self, e):
if e.Id == ID_FIRST_RESULT:
logger.debug('ID_FIRST_RESULT')
self.pageNumberCtrl.SetSelection(self.page.getFirstPageNumber())
self.paginationBar.EnableTool(ID_FIRST_RESULT, False)
self.paginationBar.EnableTool(ID_PREVIOUS_RESULT, False)
self.paginationBar.EnableTool(ID_NEXT_RESULT, True)
if e.Id == ID_PREVIOUS_RESULT:
logger.debug('ID_PREVIOUS_RESULT')
if self.page.hasPrevious():
self.paginationBar.EnableTool(ID_NEXT_RESULT, True)
self.paginationBar.EnableTool(ID_LAST_RESULT, True)
self.pageNumberCtrl.SetSelection(self.page.getPreviousPageNumber())
else:
self.paginationBar.EnableTool(ID_PREVIOUS_RESULT, False)
self.paginationBar.EnableTool(ID_FIRST_RESULT, False)
if e.Id == ID_NEXT_RESULT:
logger.debug('ID_NEXT_RESULT')
if self.page.hasNext():
self.paginationBar.EnableTool(ID_PREVIOUS_RESULT, True)
self.paginationBar.EnableTool(ID_FIRST_RESULT, True)
self.paginationBar.EnableTool(ID_LAST_RESULT, True)
nextPageNumber = self.page.getNextPageNumber()
logger.debug(nextPageNumber)
self.pageNumberCtrl.SetSelection(nextPageNumber)
else:
self.paginationBar.EnableTool(ID_NEXT_RESULT, False)
self.paginationBar.EnableTool(ID_LAST_RESULT, False)
if e.Id == ID_LAST_RESULT:
logger.debug('ID_LAST_RESULT')
self.pageNumberCtrl.SetSelection(self.page.getLastPageNumber())
self.paginationBar.EnableTool(ID_LAST_RESULT, False)
self.paginationBar.EnableTool(ID_NEXT_RESULT, False)
self.paginationBar.EnableTool(ID_FIRST_RESULT, True)
self.paginationBar.EnableTool(ID_PREVIOUS_RESULT, True)
self.paginationBar.Realize()
self.loadingBook()
self.updatePangnation()
def reloadingDatabase(self, event):
logger.debug('reloadingDatabase')
self.createDatabase = CreateDatabase(libraryPath=self.libraryPath)
self.createDatabase.creatingDatabase()
self.createDatabase.addingData()
self.loadingBook(searchText=self.search.GetValue())
class OtherViewBaseTreePanel(ExpansionState, TreeCtrl):
'''
Left navigation tree in preferences page
'''
def __init__(self, parent):
TreeCtrl.__init__(self, parent, style=wx.TR_HIDE_ROOT | wx.TR_DEFAULT_STYLE |
wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.BORDER_NONE)
self._il = None
self.BuildTreeImageList()
# if USE_CUSTOMTREECTRL:
# self.SetSpacing(10)
# self.SetWindowStyle(self.GetWindowStyle() & ~wx.TR_LINES_AT_ROOT)
self.SetInitialSize((100, 80))
def AppendItem(self, parent, text, image=-1, wnd=None):
item = TreeCtrl.AppendItem(self, parent, text, image=image)
return item
def BuildTreeImageList(self):
# imgList = wx.ImageList(16, 16)
#
# for png in _demoPngs:
# imgList.Add(catalog[png].GetBitmap())
#
# # add the image for modified demos.
# imgList.Add(catalog["custom"].GetBitmap())
#
# self.AssignImageList(imgList)
if self._il:
self._il.Destroy()
self._il = None
self._il = wx.ImageList(16, 16)
self.SetImageList(self._il)
self.ImageList.RemoveAll()
self.iconsDictIndex = {}
count = 0
self.fileOperations = FileOperations()
imageNameSet = set()
for data in importProjectDataList:
for dx in data:
if type(dx) == type(list()):
for d in dx:
imageNameSet.add(d[2])
imageNameSet.add(data[2])
imageNameList = list(imageNameSet)
# for imageName in ['preference.png', 'folderType_filter.png', 'eclipse_open_folder.png', 'fileType_filter.png', 'usb.png', 'stop.png',
# 'java.png', 'python_module.png', 'xml.png', "other_view.png", 'console_view.png', 'register_view.png',
# 'debug_view.png' , 'history_view.png', 'compare_view.png', 'breakpoint_view.png', 'watchlist_view.png',
# 'history_view.png', 'synch_synch.png', 'variable_view.png', 'internal_browser.png', 'reflog.png', 'staging.png',
# 'rebase_interactive.png', 'repo_rep.png', 'gitrepository.png','filenav_nav.png','welcome16.png','tasks_tsk.png',
# 'resource_persp.png','outline_co.png']:
imageNameList.extend(['other_view.png', 'eclipse_open_folder.png'])
for imageName in imageNameList:
try:
self.ImageList.Add(self.fileOperations.getImageBitmap(imageName=imageName))
self.iconsDictIndex[imageName] = count
count += 1
except Exception as e:
logger.error(e)
def GetItemIdentity(self, item):
return self.GetItemData(item)
def Freeze(self):
if 'wxMSW' in wx.PlatformInfo:
return super(OtherViewBaseTreePanel, self).Freeze()
def Thaw(self):
if 'wxMSW' in wx.PlatformInfo:
return super(OtherViewBaseTreePanel, self).Thaw()
class RichTextPanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
# self.MakeMenuBar()
self.tbar = self.MakeToolBar()
# self.CreateStatusBar()
# self.SetStatusText("Welcome to wx.richtext.RichTextCtrl!")
self.rtc = rt.RichTextCtrl(self,
-1,
style=wx.VSCROLL | wx.HSCROLL
| wx.NO_BORDER)
# handler = rt.RichTextHTMLHandler()
wx.CallAfter(self.rtc.SetFocus)
# self.rtc.Freeze()
# self.rtc.BeginSuppressUndo()
#
# self.rtc.EndSuppressUndo()
# self.rtc.Thaw()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.tbar, 0, wx.EXPAND | wx.ALL, 1)
sizer.Add(self.rtc, 1, wx.EXPAND | wx.ALL, 1)
# sizer.Add(save_button, 1, wx.EXPAND | wx.ALL, 1)
self.SetSizer(sizer)
self.book = args[0]
self.loadFile()
# self.Show()
def loadFile(self):
# path = os.path.join('/docs/github/Opal/src/ui/view/opalview', 'bookInfo.html')
out = StringIO()
htmlhandler = rt.RichTextHTMLHandler()
buffer = self.rtc.GetBuffer()
# htmlhandler.SetFlags(rt.RICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY)
htmlhandler.SetFontSizeMapping([7, 9, 11, 12, 14, 22, 100])
logger.debug('canload: %s', htmlhandler.CanLoad())
logger.debug('cansave: %s', htmlhandler.CanSave())
logger.debug('CanHandle: %s', htmlhandler.CanHandle('bookInfo.html'))
rt.RichTextBuffer.AddHandler(htmlhandler)
# buffer.AddHandler(htmlhandler)
try:
if self.book != None:
out.write(self.book.bookDescription)
out.seek(0)
except Exception as e:
logger.error(e)
# htmlhandler.LoadStream(buffer, out)
# htmlhandler.LoadFile(path,'text')
if self.book != None and self.book.bookDescription != None:
self.rtc.AppendText(self.book.bookDescription)
# htmlhandler.LoadStream(buffer, out.getvalue())
self.rtc.Refresh()
# buffer = self.rtc.GetBuffer()
# you have to specify the type of data to load and the control
# must already have an instance of the handler to parse it
# buffer.LoadStream(stream, rt.RICHTEXT_TYPE_HTML)
# self.rtc.Refresh()
# self.rtc.LoadFile(path, type=1)
def OnFileSave(self, evt):
# self.loadFile()
self.GetParent().save()
# handler = rt.RichTextHTMLHandler()
# handler.SetFlags(rt.RICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY)
# handler.SetFontSizeMapping([7, 9, 11, 12, 14, 22, 100])
#
# import cStringIO
# stream = cStringIO.StringIO()
# if not handler.SaveStream(self.rtc.GetBuffer(), stream):
# return
# html_content = stream.getvalue()
# print html_content
def SetFontStyle(self,
fontColor=None,
fontBgColor=None,
fontFace=None,
fontSize=None,
fontBold=None,
fontItalic=None,
fontUnderline=None):
if fontColor:
self.textAttr.SetTextColour(fontColor)
if fontBgColor:
self.textAttr.SetBackgroundColour(fontBgColor)
if fontFace:
self.textAttr.SetFontFaceName(fontFace)
if fontSize:
self.textAttr.SetFontSize(fontSize)
if fontBold != None:
if fontBold:
self.textAttr.SetFontWeight(wx.FONTWEIGHT_BOLD)
else:
self.textAttr.SetFontWeight(wx.FONTWEIGHT_NORMAL)
if fontItalic != None:
if fontItalic:
self.textAttr.SetFontStyle(wx.FONTSTYLE_ITALIC)
else:
self.textAttr.SetFontStyle(wx.FONTSTYLE_NORMAL)
if fontUnderline != None:
if fontUnderline:
self.textAttr.SetFontUnderlined(True)
else:
self.textAttr.SetFontUnderlined(False)
self.rtc.SetDefaultStyle(self.textAttr)
def OnURL(self, evt):
wx.MessageBox(evt.GetString(), "URL Clicked")
def OnFileOpen(self, evt):
# This gives us a string suitable for the file dialog based on
# the file handlers that are loaded
wildcard, types = rt.RichTextBuffer.GetExtWildcard(save=False)
dlg = wx.FileDialog(
self,
"Choose a filename",
wildcard=wildcard,
)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
if path:
fileType = types[dlg.GetFilterIndex()]
self.rtc.LoadFile(path, fileType)
dlg.Destroy()
#
# if not self.rtc.GetFilename():
# self.OnFileSaveAs(evt)
# return
# self.rtc.SaveFile()
def OnFileSaveAs(self, evt):
wildcard, types = rt.RichTextBuffer.GetExtWildcard(save=True)
dlg = wx.FileDialog(
self,
"Choose a filename",
wildcard=wildcard,
)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
if path:
fileType = types[dlg.GetFilterIndex()]
ext = rt.RichTextBuffer.FindHandlerByType(
fileType).GetExtension()
if not path.endswith(ext):
path += '.' + ext
self.rtc.SaveFile(path, fileType)
dlg.Destroy()
def OnFileViewHTML(self, evt):
# Get an instance of the html file handler, use it to save the
# document to a StringIO stream, and then display the
# resulting html text in a dialog with a HtmlWindow.
handler = rt.RichTextHTMLHandler()
handler.SetFlags(rt.RICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY)
handler.SetFontSizeMapping([7, 9, 11, 12, 14, 22, 100])
import cStringIO
stream = cStringIO()
if not handler.SaveStream(self.rtc.GetBuffer(), stream):
return
import wx.html
dlg = wx.Dialog(self,
title="HTML",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
html = wx.html.HtmlWindow(dlg, size=(500, 400), style=wx.BORDER_SUNKEN)
html.SetPage(stream.getvalue())
btn = wx.Button(dlg, wx.ID_CANCEL)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(html, 1, wx.ALL | wx.EXPAND, 5)
sizer.Add(btn, 0, wx.ALL | wx.CENTER, 10)
dlg.SetSizer(sizer)
sizer.Fit(dlg)
dlg.ShowModal()
handler.DeleteTemporaryImages()
def OnFileExit(self, evt):
self.Close(True)
def OnBold(self, evt):
self.rtc.ApplyBoldToSelection()
def OnItalic(self, evt):
self.rtc.ApplyItalicToSelection()
def OnUnderline(self, evt):
self.rtc.ApplyUnderlineToSelection()
def OnAlignLeft(self, evt):
self.rtc.ApplyAlignmentToSelection(wx.TEXT_ALIGNMENT_LEFT)
def OnAlignRight(self, evt):
self.rtc.ApplyAlignmentToSelection(wx.TEXT_ALIGNMENT_RIGHT)
def OnAlignCenter(self, evt):
self.rtc.ApplyAlignmentToSelection(wx.TEXT_ALIGNMENT_CENTRE)
def OnIndentMore(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
attr.SetLeftIndent(attr.GetLeftIndent() + 100)
attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
self.rtc.SetStyle(r, attr)
def OnIndentLess(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
if attr.GetLeftIndent() >= 100:
attr.SetLeftIndent(attr.GetLeftIndent() - 100)
attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
self.rtc.SetStyle(r, attr)
def OnParagraphSpacingMore(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
attr.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter() + 20)
attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
self.rtc.SetStyle(r, attr)
def OnParagraphSpacingLess(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
if attr.GetParagraphSpacingAfter() >= 20:
attr.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter() -
20)
attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
self.rtc.SetStyle(r, attr)
def OnLineSpacingSingle(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
attr.SetLineSpacing(10)
self.rtc.SetStyle(r, attr)
def OnLineSpacingHalf(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
attr.SetLineSpacing(15)
self.rtc.SetStyle(r, attr)
def OnLineSpacingDouble(self, evt):
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
ip = self.rtc.GetInsertionPoint()
if self.rtc.GetStyle(ip, attr):
r = rt.RichTextRange(ip, ip)
if self.rtc.HasSelection():
r = self.rtc.GetSelectionRange()
attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
attr.SetLineSpacing(20)
self.rtc.SetStyle(r, attr)
def OnFont(self, evt):
if not self.rtc.HasSelection():
return
r = self.rtc.GetSelectionRange()
fontData = wx.FontData()
fontData.EnableEffects(False)
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_FONT)
if self.rtc.GetStyle(self.rtc.GetInsertionPoint(), attr):
fontData.SetInitialFont(attr.GetFont())
dlg = wx.FontDialog(self, fontData)
if dlg.ShowModal() == wx.ID_OK:
fontData = dlg.GetFontData()
font = fontData.GetChosenFont()
if font:
attr.SetFlags(wx.TEXT_ATTR_FONT)
attr.SetFont(font)
self.rtc.SetStyle(r, attr)
dlg.Destroy()
def OnColour(self, evt):
colourData = wx.ColourData()
attr = wx.TextAttr()
attr.SetFlags(wx.TEXT_ATTR_TEXT_COLOUR)
if self.rtc.GetStyle(self.rtc.GetInsertionPoint(), attr):
colourData.SetColour(attr.GetTextColour())
dlg = wx.ColourDialog(self, colourData)
if dlg.ShowModal() == wx.ID_OK:
colourData = dlg.GetColourData()
colour = colourData.GetColour()
if colour:
if not self.rtc.HasSelection():
self.rtc.BeginTextColour(colour)
else:
r = self.rtc.GetSelectionRange()
attr.SetFlags(wx.TEXT_ATTR_TEXT_COLOUR)
attr.SetTextColour(colour)
self.rtc.SetStyle(r, attr)
dlg.Destroy()
def OnUpdateBold(self, evt):
evt.Check(self.rtc.IsSelectionBold())
def OnUpdateItalic(self, evt):
evt.Check(self.rtc.IsSelectionItalics())
def OnUpdateUnderline(self, evt):
evt.Check(self.rtc.IsSelectionUnderlined())
def OnUpdateAlignLeft(self, evt):
evt.Check(self.rtc.IsSelectionAligned(wx.TEXT_ALIGNMENT_LEFT))
def OnUpdateAlignCenter(self, evt):
evt.Check(self.rtc.IsSelectionAligned(wx.TEXT_ALIGNMENT_CENTRE))
def OnUpdateAlignRight(self, evt):
evt.Check(self.rtc.IsSelectionAligned(wx.TEXT_ALIGNMENT_RIGHT))
def ForwardEvent(self, evt):
# The RichTextCtrl can handle menu and update events for undo,
# redo, cut, copy, paste, delete, and select all, so just
# forward the event to it.
self.rtc.ProcessEvent(evt)
# def MakeMenuBar(self):
#
# def doBind(item, handler, updateUI=None):
# self.Bind(wx.EVT_MENU, handler, item)
# if updateUI is not None:
# self.Bind(wx.EVT_UPDATE_UI, updateUI, item)
#
# fileMenu = wx.Menu()
# doBind(fileMenu.Append(-1, "&Open\tCtrl+O", "Open a file"),
# self.OnFileOpen)
# doBind(fileMenu.Append(-1, "&Save\tCtrl+S", "Save a file"),
# self.OnFileSave)
# doBind(fileMenu.Append(-1, "&Save As...\tF12", "Save to a new file"),
# self.OnFileSaveAs)
# fileMenu.AppendSeparator()
# doBind(fileMenu.Append(-1, "&View as HTML", "View HTML"),
# self.OnFileViewHTML)
# fileMenu.AppendSeparator()
# doBind(fileMenu.Append(-1, "E&xit\tCtrl+Q", "Quit this program"),
# self.OnFileExit)
#
# editMenu = wx.Menu()
# doBind(editMenu.Append(wx.ID_UNDO, "&Undo\tCtrl+Z"),
# self.ForwardEvent, self.ForwardEvent)
# doBind(editMenu.Append(wx.ID_REDO, "&Redo\tCtrl+Y"),
# self.ForwardEvent, self.ForwardEvent)
# editMenu.AppendSeparator()
# doBind(editMenu.Append(wx.ID_CUT, "Cu&t\tCtrl+X"),
# self.ForwardEvent, self.ForwardEvent)
# doBind(editMenu.Append(wx.ID_COPY, "&Copy\tCtrl+C"),
# self.ForwardEvent, self.ForwardEvent)
# doBind(editMenu.Append(wx.ID_PASTE, "&Paste\tCtrl+V"),
# self.ForwardEvent, self.ForwardEvent)
# doBind(editMenu.Append(wx.ID_CLEAR, "&Delete\tDel"),
# self.ForwardEvent, self.ForwardEvent)
# editMenu.AppendSeparator()
# doBind(editMenu.Append(wx.ID_SELECTALL, "Select A&ll\tCtrl+A"),
# self.ForwardEvent, self.ForwardEvent)
#
# # doBind( editMenu.AppendSeparator(), )
# # doBind( editMenu.Append(-1, "&Find...\tCtrl+F"), )
# # doBind( editMenu.Append(-1, "&Replace...\tCtrl+R"), )
#
# formatMenu = wx.Menu()
# doBind(formatMenu.AppendCheckItem(-1, "&Bold\tCtrl+B"),
# self.OnBold, self.OnUpdateBold)
# doBind(formatMenu.AppendCheckItem(-1, "&Italic\tCtrl+I"),
# self.OnItalic, self.OnUpdateItalic)
# doBind(formatMenu.AppendCheckItem(-1, "&Underline\tCtrl+U"),
# self.OnUnderline, self.OnUpdateUnderline)
# formatMenu.AppendSeparator()
# doBind(formatMenu.AppendCheckItem(-1, "L&eft Align"),
# self.OnAlignLeft, self.OnUpdateAlignLeft)
# doBind(formatMenu.AppendCheckItem(-1, "&Centre"),
# self.OnAlignCenter, self.OnUpdateAlignCenter)
# doBind(formatMenu.AppendCheckItem(-1, "&Right Align"),
# self.OnAlignRight, self.OnUpdateAlignRight)
# formatMenu.AppendSeparator()
# doBind(formatMenu.Append(-1, "Indent &More"), self.OnIndentMore)
# doBind(formatMenu.Append(-1, "Indent &Less"), self.OnIndentLess)
# formatMenu.AppendSeparator()
# doBind(formatMenu.Append(-1, "Increase Paragraph &Spacing"), self.OnParagraphSpacingMore)
# doBind(formatMenu.Append(-1, "Decrease &Paragraph Spacing"), self.OnParagraphSpacingLess)
# formatMenu.AppendSeparator()
# doBind(formatMenu.Append(-1, "Normal Line Spacing"), self.OnLineSpacingSingle)
# doBind(formatMenu.Append(-1, "1.5 Line Spacing"), self.OnLineSpacingHalf)
# doBind(formatMenu.Append(-1, "Double Line Spacing"), self.OnLineSpacingDouble)
# formatMenu.AppendSeparator()
# doBind(formatMenu.Append(-1, "&Font..."), self.OnFont)
#
# mb = wx.MenuBar()
# mb.Append(fileMenu, "&File")
# mb.Append(editMenu, "&Edit")
# mb.Append(formatMenu, "F&ormat")
# self.SetMenuBar(mb)
def MakeToolBar(self):
def doBind(item, handler, updateUI=None):
self.Bind(wx.EVT_TOOL, handler, item)
if updateUI is not None:
self.Bind(wx.EVT_UPDATE_UI, updateUI, item)
self.fileOperations = FileOperations()
tbar = wx.ToolBar(self, style=wx.TB_FLAT)
doBind(
tbar.AddTool(
-1, "Open",
self.fileOperations.getImageBitmap(
imageName='eclipse_open_folder.png'), "Open"),
self.OnFileOpen)
doBind(
tbar.AddTool(
-1, "Save",
self.fileOperations.getImageBitmap(imageName='save.png'),
"Save"), self.OnFileSave)
tbar.AddSeparator()
doBind(
tbar.AddTool(
wx.ID_CUT, "Cut",
self.fileOperations.getImageBitmap(imageName='cut_edit.png')),
self.ForwardEvent, self.ForwardEvent)
doBind(
tbar.AddTool(
wx.ID_COPY, "Copy",
self.fileOperations.getImageBitmap(
imageName='copy_edit_co.png')), self.ForwardEvent,
self.ForwardEvent)
doBind(
tbar.AddTool(
wx.ID_PASTE, "Paste",
self.fileOperations.getImageBitmap(
imageName='paste_edit.png')), self.ForwardEvent,
self.ForwardEvent)
# doBind(tbar.AddTool(wx.ID_COPY, images._rt_copy.GetBitmap(), shortHelpString="Copy"), self.ForwardEvent, self.ForwardEvent)
# doBind(tbar.AddTool(wx.ID_PASTE, images._rt_paste.GetBitmap(), shortHelpString="Paste"), self.ForwardEvent, self.ForwardEvent)
tbar.AddSeparator()
doBind(
tbar.AddTool(
wx.ID_UNDO, "Undo",
self.fileOperations.getImageBitmap(imageName='undo_edit.png')),
self.ForwardEvent, self.ForwardEvent)
doBind(
tbar.AddTool(
wx.ID_REDO, "Redo",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.ForwardEvent, self.ForwardEvent)
# doBind(tbar.AddTool(wx.ID_UNDO, images._rt_undo.GetBitmap(), shortHelpString="Undo"), self.ForwardEvent, self.ForwardEvent)
# doBind(tbar.AddTool(wx.ID_REDO, images._rt_redo.GetBitmap(), shortHelpString="Redo"), self.ForwardEvent, self.ForwardEvent)
tbar.AddSeparator()
doBind(
tbar.AddTool(
-1, "Bold",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnBold, self.OnUpdateBold)
doBind(
tbar.AddTool(
-1, "Italic",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnItalic, self.OnUpdateItalic)
doBind(
tbar.AddTool(
-1, "Underline",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnUnderline, self.OnUpdateUnderline)
# doBind(tbar.AddTool(-1, images._rt_bold.GetBitmap(), isToggle=True, shortHelpString="Bold"), self.OnBold, self.OnUpdateBold)
# doBind(tbar.AddTool(-1, images._rt_italic.GetBitmap(), isToggle=True, shortHelpString="Italic"), self.OnItalic, self.OnUpdateItalic)
# doBind(tbar.AddTool(-1, images._rt_underline.GetBitmap(), isToggle=True, shortHelpString="Underline"), self.OnUnderline, self.OnUpdateUnderline)
tbar.AddSeparator()
doBind(
tbar.AddTool(
-1, "Align Left",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnAlignLeft, self.OnUpdateAlignLeft)
doBind(
tbar.AddTool(
-1, "Center",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnAlignCenter, self.OnUpdateAlignCenter)
doBind(
tbar.AddTool(
-1, "Align Right",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnAlignRight, self.OnUpdateAlignRight)
# doBind(tbar.AddTool(-1, images._rt_alignleft.GetBitmap(), isToggle=True, shortHelpString="Align Left"), self.OnAlignLeft, self.OnUpdateAlignLeft)
# doBind(tbar.AddTool(-1, images._rt_centre.GetBitmap(), isToggle=True, shortHelpString="Center"), self.OnAlignCenter, self.OnUpdateAlignCenter)
# doBind(tbar.AddTool(-1, images._rt_alignright.GetBitmap(), isToggle=True, shortHelpString="Align Right"), self.OnAlignRight, self.OnUpdateAlignRight)
tbar.AddSeparator()
doBind(
tbar.AddTool(
-1, "Indent Less",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnIndentLess)
doBind(
tbar.AddTool(
-1, "Indent More",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnIndentMore)
# doBind(tbar.AddTool(-1, images._rt_indentless.GetBitmap(), shortHelpString="Indent Less"), self.OnIndentLess)
# doBind(tbar.AddTool(-1, images._rt_indentmore.GetBitmap(), shortHelpString="Indent More"), self.OnIndentMore)
tbar.AddSeparator()
doBind(
tbar.AddTool(
-1, "Font",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnFont)
doBind(
tbar.AddTool(
-1, "Font Colour",
self.fileOperations.getImageBitmap(imageName='redo_edit.png')),
self.OnColour)
# doBind(tbar.AddTool(-1, images._rt_font.GetBitmap(), shortHelpString="Font"), self.OnFont)
# doBind(tbar.AddTool(-1, images._rt_colour.GetBitmap(), shortHelpString="Font Colour"), self.OnColour)
tbar.Realize()
return tbar
class SimpleGrid(wx.grid.Grid):
def __init__(self, parent):
wx.grid.Grid.__init__(self, parent, -1, size=(600, 500))
self.CreateGrid(1, 1)
self.RowLabelSize = 32
self.dataTypeList = [("INTEGER", 0), ("VARCHAR", 1), ("TEXT", 2), ("REAL", 3), ("BLOB", 4), ("NUMERIC", 5)]
self.checkBoxColumns = ['nullable', 'unique', 'primaryKey', 'autoIncrement']
self.textBoxColumns = ['name', 'defultValue', 'description']
self.comboBoxList = ['dataType']
self.iconColumns = [0]
self.columns = None
self.fileOperations = FileOperations()
self.addImages()
self.lastSelectedCell = None
self.bindAllEvent()
def addImages(self):
self.bmpList = list()
self.bmpList.append(self.fileOperations.getImageBitmap(imageName="key.png")) # 0 for primary key
self.bmpList.append(self.fileOperations.getImageBitmap(imageName="textfield.png")) # 1 for varchar, char, text column
self.bmpList.append(self.fileOperations.getImageBitmap(imageName="unique_constraint.png")) # 2 for unique key column
self.bmpList.append(self.fileOperations.getImageBitmap(imageName="datetime.png")) # 3 for datetime field column
self.bmpList.append(self.fileOperations.getImageBitmap(imageName="column.png")) # 4 for integer key column
def bindAllEvent(self):
# test all the events
self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnCellLeftClick)
self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.OnCellRightClick)
self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.OnCellLeftDClick)
self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_DCLICK, self.OnCellRightDClick)
self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.OnLabelLeftClick)
self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.OnLabelRightClick)
self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_DCLICK, self.OnLabelLeftDClick)
self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_DCLICK, self.OnLabelRightDClick)
self.Bind(wx.grid.EVT_GRID_ROW_SIZE, self.OnRowSize)
self.Bind(wx.grid.EVT_GRID_COL_SIZE, self.OnColSize)
self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
self.Bind(wx.grid.EVT_GRID_CELL_CHANGED, self.OnCellChange)
self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.OnSelectCell)
self.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN, self.OnEditorShown)
self.Bind(wx.grid.EVT_GRID_EDITOR_HIDDEN, self.OnEditorHidden)
self.Bind(wx.grid.EVT_GRID_EDITOR_CREATED, self.OnEditorCreated)
########################### Check box start ###################################
def OnCellLeftClick(self, evt):
logger.debug(f"OnCellLeftClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()}")
row = evt.GetRow()
col = evt.GetCol()
if evt.GetCol() in self.checkBoxColumns:
logger.debug(self.GetCellValue(row, col))
wx.MilliSleep(100)
# self.toggleCheckBox(row, col)
wx.CallLater(100, self.toggleCheckBox, (row, col))
evt.Skip()
def toggleCheckBox(self, cell):
logger.debug(f'toggleCheckBox {cell}')
try:
self.cb.Value = not self.cb.Value
self.afterCheckBox(self.cb.Value, cell)
except Exception as e:
logger.error(e, exc_info=True)
def afterCheckBox(self, isChecked, cell):
logger.debug(f'afterCheckBox GridCursorRow:{self.GridCursorRow} , isChecked:{isChecked} , cell:{cell}')
try:
self.isChecked = isChecked
row, col = cell
if self.isChecked:
self.SetCellValue(row, col, '1')
if col == 3:
# Setting image icon for primary key
self.SetCellValue(row, 0, "0")
else:
# setting blank for un-check column
self.SetCellValue(row, col, '')
dataType = self.GetCellValue(row, 2)
if dataType == 'INTEGER':
# setting image icon for integer column
self.SetCellValue(row, 0, "4")
elif dataType in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
for d in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
if dataType.lower().startswith(d.lower()):
self.SetCellValue(row, 0, "1")
break
# setting image icon for integer column
self.Refresh()
except Exception as e:
logger.error(e, exc_info=True)
def OnEditorCreated(self, evt):
logger.debug(f"OnEditorCreated: ({evt.GetRow()}, {evt.GetCol()}) {evt.GetControl().Value}")
row = evt.GetRow()
col = evt.GetCol()
self.lastSelectedCell = (row, col)
# In this example, all cells in row 0 are GridCellChoiceEditors,
# so we need to setup the selection list and bindings. We can't
# do this in advance, because the ComboBox control is created with
# the editor.
if self.GetColLabelValue(col) in self.comboBoxList:
# Get a reference to the underlying ComboBox control.
self.comboBox = evt.GetControl()
# Bind the ComboBox events.
self.comboBox.Bind(wx.EVT_COMBOBOX, self.OnGridComboBox)
self.comboBox.Bind(wx.EVT_TEXT, self.OnGridComboBoxText)
# Load the initial choice list.
for (item, data) in self.dataTypeList:
self.comboBox.Append(item, data)
elif self.GetColLabelValue(col) in self.checkBoxColumns:
self.cb = evt.Control
self.cb.WindowStyle |= wx.WANTS_CHARS
self.cb.Bind(wx.EVT_KEY_DOWN, self.onKeyDown)
self.cb.Bind(wx.EVT_CHECKBOX, self.onCheckBox)
logger.debug(f"After change OnEditorCreated: ({evt.GetRow()}, {evt.GetCol()}) {evt.GetControl().Value}")
evt.Skip()
def onKeyDown(self, evt):
if evt.KeyCode == wx.WXK_UP:
if self.GridCursorRow > 0:
self.DisableCellEditControl()
self.MoveCursorUp(False)
elif evt.KeyCode == wx.WXK_DOWN:
if self.GridCursorRow < (self.NumberRows - 1):
self.DisableCellEditControl()
self.MoveCursorDown(False)
elif evt.KeyCode == wx.WXK_LEFT:
if self.GridCursorCol > 0:
self.DisableCellEditControl()
self.MoveCursorLeft(False)
elif evt.KeyCode == wx.WXK_RIGHT:
if self.GridCursorCol < (self.NumberCols - 1):
self.DisableCellEditControl()
self.MoveCursorRight(False)
else:
evt.Skip()
def onCheckBox(self, evt):
logger.debug('onCheckBox lastSelectedCell:%s', self.lastSelectedCell)
if self.lastSelectedCell:
self.afterCheckBox(evt.IsChecked(), cell=self.lastSelectedCell)
########################### Check box close ###################################
def OnCellRightClick(self, evt):
logger.debug(f"OnCellRightClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnCellLeftDClick(self, evt):
logger.debug(f"OnCellLeftDClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnCellRightDClick(self, evt):
logger.debug(f"OnCellRightDClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnLabelLeftClick(self, evt):
logger.debug(f"OnLabelLeftClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnLabelRightClick(self, evt):
logger.debug(f"OnLabelRightClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnLabelLeftDClick(self, evt):
logger.debug(f"OnLabelLeftDClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnLabelRightDClick(self, evt):
logger.debug(f"OnLabelRightDClick: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()})")
evt.Skip()
def OnRowSize(self, evt):
logger.debug(f"OnRowSize: row {evt.GetRowOrCol()}, {evt.GetPosition()}")
evt.Skip()
def OnColSize(self, evt):
logger.debug("OnColSize: col %d, %s" , evt.GetRowOrCol(),
evt.GetPosition())
evt.Skip()
def OnRangeSelect(self, evt):
if evt.Selecting():
msg = 'Selected'
else:
msg = 'Deselected'
logger.debug(f"OnRangeSelect: {msg} top-left {evt.GetTopLeftCoords()}, bottom-right { evt.GetBottomRightCoords()}")
evt.Skip()
def updateIconColumn(self, cell=None, cellValue=None):
row, col = cell
logger.debug(f'updateIconColumn {cell}, {cellValue}')
self.columns[row].__setattr__(self.GetColLabelValue(col), cellValue)
self.GetParent().sqlType.columns = self.columns
pub.sendMessage('OnCellChange', sqlType=self.GetParent().sqlType)
# if self.GetColLabelValue(col) == 'dataType':
# targetRow = row
# targetCol=0
# if cellValue in ["INTEGER", "INT"]:
# self.SetCellValue(targetRow, targetCol, "4")
# elif cellValue.upper() in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
# # self.SetCellValue(targetRow, targetCol,"1")
# isPrimaryKey = self.GetCellValue(row, 3)
# if not isPrimaryKey == 1:
# for d in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
# if cellValue.lower().startswith(d.lower()):
# self.SetCellValue(targetRow, targetCol, "1")
# break
def OnCellChange(self, evt):
# Show how to stay in a cell that has bad data. We can't just
# call SetGridCursor here since we are nested inside one so it
# won't have any effect. Instead, set coordinates to move to in
# idle time.
sourceValue = self.GetCellValue(evt.GetRow(), evt.GetCol())
logger.debug(f"OnCellChange: ({evt.GetRow()},{evt.GetCol()}) {evt.GetPosition()} , cellValue : {sourceValue}")
sourceRow = evt.GetRow()
sourceCol = evt.GetCol()
self.updateIconColumn(cell=(evt.GetRow(), evt.GetCol()), cellValue=sourceValue)
# if sourceCol == 2:
# targetRow = sourceRow
# targetCol = 0
# if sourceValue in ["INTEGER", "INT"]:
# self.SetCellValue(targetRow, targetCol, "4")
# elif sourceValue.upper() in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
# # self.SetCellValue(targetRow, targetCol,"1")
# isPrimaryKey = self.GetCellValue(sourceRow, 3)
# if not isPrimaryKey == 1:
# for d in ['VARCHAR', 'CHAR', 'REAL', 'TEXT']:
# if sourceValue.lower().startswith(d.lower()):
# self.SetCellValue(targetRow, targetCol, "1")
# break
self.Refresh()
# if value == 'no good':
# self.moveTo = evt.GetRow(), evt.GetCol()
# #All cells have a value, regardless of the editor.
# print 'Changed cell: (%u, %u)' % (Row, Col)
# print 'value: %s' % self.grid1.GetCellValue(Row, Col)
#
# #Row 0 means a GridCellChoiceEditor, so we should have associated
# #an index and client data.
# if Row == 0:
# print 'index: %u' % self.index
# print 'data: %s' % self.data
#
# print '' #blank line to make it pretty.
# event.Skip()
def OnSelectCell(self, evt):
if evt.Selecting():
msg = 'Selected'
else:
msg = 'Deselected'
logger.debug("OnSelectCell: %s (%d,%d) %s" , msg, evt.GetRow(),
evt.GetCol(), evt.GetPosition())
#
row = self.GetGridCursorRow()
col = self.GetGridCursorCol()
#
# if self.IsCellEditControlEnabled():
# self.HideCellEditControl()
# self.DisableCellEditControl()
# if row > -1 and col > -1:
# value = self.GetCellValue(row, col)
#
# if value == 'no good 2':
# return # cancels the cell selection
# evt.Skip()
if evt.Col in self.checkBoxColumns:
wx.CallAfter(self.EnableCellEditControl)
evt.Skip()
def OnEditorShown(self, evt):
if evt.GetRow() == 6 and evt.GetCol() == 3 and \
wx.MessageBox("Are you sure you wish to edit this cell?",
"Checking", wx.YES_NO) == wx.NO:
evt.Veto()
return
logger.debug("OnEditorShown: (%d,%d) %s" , evt.GetRow(), evt.GetCol(),
evt.GetPosition())
evt.Skip()
def OnEditorHidden(self, evt):
if evt.GetRow() == 6 and evt.GetCol() == 3 and \
wx.MessageBox("Are you sure you wish to finish editing this cell?",
"Checking", wx.YES_NO) == wx.NO:
evt.Veto()
return
logger.debug("OnEditorHidden: (%d,%d) %s" , evt.GetRow(),
evt.GetCol(),
evt.GetPosition())
evt.Skip()
# This method fires when the underlying GridCellChoiceEditor ComboBox
# is done with a selection.
def OnGridComboBox(self, event):
# Save the index and client data for later use.
self.index = self.comboBox.GetSelection()
self.data = self.comboBox.GetClientData(self.index)
logger.debug('ComboBoxChanged: %s' , self.comboBox.GetValue())
logger.debug('ComboBox index: %u' , self.index)
logger.debug('ComboBox data: %u' , self.data)
event.Skip()
# This method fires when any text editing is done inside the text portion
# of the ComboBox. This method will fire once for each new character, so
# the print statements will show the character by character changes.
def OnGridComboBoxText(self, event):
# The index for text changes is always -1. This is how we can tell
# that new text has been entered, as opposed to a simple selection
# from the drop list. Note that the index will be set for each character,
# but it will be -1 every time, so the final result of text changes is
# always an index of -1. The value is whatever text that has been
# entered. At this point there is no client data. We will have to add
# that later, once all of the text has been entered.
self.index = self.comboBox.GetSelection()
logger.debug('ComboBoxText: %s' , self.comboBox.GetValue())
logger.debug('ComboBox index: %u' , self.index)
# self.sql
# selectedColName = self.GetParent().tableDict['row'][0][self.lastSelectedCell[1]]
# colName = "".join(selectedColName.split(' ')).lower()
# columns = self.GetParent().tableDict['rows'][self.lastSelectedCell[0]].keys()
# for col in columns:
# if colName in col.lower():
# colName = col
# break
#
# logger.debug("currentValue:%s", self.GetParent().tableDict['rows'][self.lastSelectedCell[0]][colName])
# self.GetParent().tableDict['rows'][self.lastSelectedCell[0]][colName] = self.comboBox.GetValue()
# self.GetParent().updateTableEditorPanel()
# self.updateGridCell()
event.Skip()
def updateGridCell(self):
'''
This method will be called as soon as a comboBox value changes.
'''
pass
def addData(self, columns=None):
self.columns = columns
# print(self.GetRowSizes())
# print(self.GetColSizes())
self.ClearGrid()
if columns and len(columns) > 0:
logger.debug('rows:%s', self.GetNumberRows())
logger.debug('cols:%s', self.GetNumberCols())
# self.DeleteRows()
currentRows, currentCols = (self.GetNumberRows(), self.GetNumberCols())
newRows = len(columns)
newCols = len(columns[0].__dict__)
# self.AppendRows(numRows=len(data)-1, updateLabels=True)
# if len(data) > 0 :
# self.AppendCols(numCols=len(data[0]), updateLabels=True)
if newRows < currentRows:
# - Delete rows:
self.DeleteRows(0, currentRows - newRows, True)
if newRows > currentRows:
# - append currentRows:
self.AppendRows(newRows - currentRows)
if newCols < currentCols:
# - Delete rows:
self.DeleteCols(pos=0, numCols=currentCols - newCols, updateLabels=True)
if newCols > currentCols:
# - append currentRows:
self.AppendCols(newCols - currentCols)
self.loadGridData(columns)
else:
numCols = self.GetNumberCols()
numRows = self.GetNumberRows()
if numRows > 0:
self.DeleteRows(pos=0, numRows=numRows, updateLabels=True)
if numCols > 0:
self.DeleteCols(pos=0, numCols=numCols, updateLabels=True)
self.Refresh()
# self.Update()
def setColumnWidth(self, col):
if col == 0:
self.SetColSize(col, 30)
elif col == 1:
self.SetColSize(col, 140)
elif col == 2:
self.SetColSize(col, 90)
elif col == 3:
self.SetColSize(col, 60)
elif col == 4:
self.SetColSize(col, 100)
elif col == 5:
self.SetColSize(col, 70)
elif col == 6:
self.SetColSize(col, 70)
elif col == 7:
self.SetColSize(col, 150)
elif col == 8:
self.SetColSize(col, 150)
elif col == 9:
self.SetColSize(col, 80)
def getImageIndex(self, column):
imageIndex = 1
if column.primaryKey == 1:
imageIndex = 0
elif column.dataType in ['VARCHAR', 'TEXT']:
imageIndex = 1
elif column.unique == 1:
imageIndex = 4
return imageIndex
def loadGridData(self, columns=None):
logger.debug('loadGridData')
for row, column in enumerate(columns):
for col, (k, v) in enumerate(column.__dict__.items()):
self.setColumnWidth(col)
logger.debug(f'({row},{col}),{k}:{v}')
if row == 0 :
self.SetColLabelValue(col, str(k))
if col == 2:
# row == 2 means data type
# Create the GridCellChoiceEditor with a blank list. Items will
# be added later at runtime. "allowOthers" allows the user to
# create new selection items on the fly.
tChoiceEditor = wx.grid.GridCellChoiceEditor([], allowOthers=True)
self.SetCellEditor(row , col, tChoiceEditor)
selectedDataType = None
for dataType in self.dataTypeList:
if v.upper() == dataType[0]:
selectedDataType = k
break
self.SetCellValue(row, col, str(v))
self.SetColSize(col, 100)
elif k in self.comboBoxList:
self.SetCellValue(row, col, str(v))
elif k in self.checkBoxColumns:
attr = wx.grid.GridCellAttr()
attr.SetEditor(wx.grid.GridCellBoolEditor())
attr.SetRenderer(wx.grid.GridCellBoolRenderer())
self.SetColAttr(col, attr)
self.SetCellValue(row , col, str(v))
elif k in self.textBoxColumns:
self.SetCellValue(row, col, str(v))
elif col in self.iconColumns:
logger.debug("self.iconColumns: %s", self.iconColumns)
self.SetColLabelValue(col, 'Icon')
attr = wx.grid.GridCellAttr()
attr.SetRenderer(GridCellIconRenderer(self.bmpList))
self.SetColAttr(col, attr)
self.SetCellValue(row, col, str(self.getImageIndex(column)))
self.SetColSize(col, 50)
def fillTableData(self, data=None):
for dataKey, dataValue in data.items():
logger.debug("dataKey:%s , dataValue: %s", dataKey, dataValue)
for idx, colValue in enumerate(dataValue):
# logger.debug(idx, dataValue)
if dataKey == 0:
self.SetColLabelValue(idx, str(colValue))
elif dataKey > 0 and idx == 2:
# idx == 2 means data type
# Create the GridCellChoiceEditor with a blank list. Items will
# be added later at runtime. "allowOthers" allows the user to
# create new selection items on the fly.
tChoiceEditor = wx.grid.GridCellChoiceEditor([], allowOthers=True)
self.SetCellEditor(dataKey - 1, idx, tChoiceEditor)
selectedDataType = None
for dataType in self.dataTypeList:
if dataType[0] == colValue:
selectedDataType = dataType
break
self.SetCellValue(dataKey - 1, idx, selectedDataType[0])
self.SetColSize(idx, 100)
elif dataKey > 0 and idx in self.comboBoxList:
self.SetCellValue(dataKey - 1, idx, str(colValue))
elif dataKey > 0 and idx in self.checkBoxColumns:
attr = wx.grid.GridCellAttr()
attr.SetEditor(wx.grid.GridCellBoolEditor())
attr.SetRenderer(wx.grid.GridCellBoolRenderer())
self.SetColAttr(idx, attr)
self.SetCellValue(dataKey - 1, idx, str(colValue))
elif dataKey > 0 and idx in self.textBoxColumns:
self.SetCellValue(dataKey - 1, idx, str(colValue))
elif dataKey > 0 and idx in self.iconColumns:
logger.debug("self.iconColumns: %s", self.iconColumns)
attr = wx.grid.GridCellAttr()
attr.SetRenderer(GridCellIconRenderer(self.bmpList))
self.SetColAttr(idx, attr)
self.SetCellValue(dataKey - 1, idx, str(colValue))
self.SetColSize(idx, 50)
if idx == 0:
self.SetColSize(idx, 50)
elif idx == 1:
self.SetColSize(idx, 140)
elif idx == 2:
self.SetColSize(idx, 150)
elif idx == 3:
self.SetColSize(idx, 120)
elif idx == 4:
self.SetColSize(idx, 100)
elif idx == 5:
self.SetColSize(idx, 70)
elif idx == 6:
self.SetColSize(idx, 150)
elif idx == 7:
self.SetColSize(idx, 150)
class DataSourcePanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
vBox = wx.BoxSizer(wx.VERTICAL)
####################################################################
self.fileOperations = FileOperations()
self.toolbar = self.constructTopToolBar()
self.tree = DatabaseTree(self)
self.filter = wx.SearchCtrl(self, style=wx.TE_PROCESS_ENTER)
self.filter.SetDescriptiveText("Type filter table name")
self.filter.ShowCancelButton(True)
# self.filter.Bind(wx.EVT_TEXT, self.recreateTree)
self.filter.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN,
lambda e: self.filter.SetValue(''))
# self.filter.Bind(wx.EVT_TEXT_ENTER, self.OnSearch)
# self.recreateTree()
# add drop target
self.SetDropTarget(DatabaseFileDropTarget(self))
# self.tree.SetExpansionState(self.expansionState)
####################################################################
####################################################################
vBox.Add(self.toolbar, 0, wx.EXPAND | wx.ALL)
vBox.Add(self.filter, 0, wx.EXPAND | wx.ALL)
vBox.Add(self.tree, 1, wx.EXPAND | wx.ALL)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(vBox, 1, wx.EXPAND, 0)
self.SetSizer(sizer)
def constructTopToolBar(self):
# create some toolbars
tb1 = aui.AuiToolBar(self,
-1,
wx.DefaultPosition, (10, 10),
agwStyle=aui.AUI_TB_DEFAULT_STYLE
| aui.AUI_TB_OVERFLOW)
# tb1.SetToolBitmapSize(wx.Size(16, 16))
tools = [
(ID_COLLAPSE_ALL, "Collapse All", "collapseall-small.png",
'Collapse All', self.onCollapseAll),
(ID_LINK_WITH_EDITOR, "Link with Editor",
"icon_link_with_editor.png", 'Link with Editor',
self.onLinkWithEditor),
(),
(ID_VIEW_MENU, "View Menu", "icon_menu.png", 'View Menu',
self.onViewMenu),
# (ID_REFRESH_ROW, "Result refresh", "resultset_refresh.png", 'Result refresh \tF5', self.onRefresh),
# (ID_ADD_ROW, "Add a new row", "row_add.png", 'Add a new row', self.onAddRow),
# (ID_DUPLICATE_ROW, "Duplicate selected row", "row_copy.png", 'Duplicate selected row', self.onDuplicateRow),
# (ID_DELETE_ROW, "Delete selected row", "row_delete.png", 'Delete selected row', self.onDeleteRow),
]
for tool in tools:
if len(tool) == 0:
tb1.AddSeparator()
else:
logger.debug(tool)
toolItem = tb1.AddSimpleTool(
tool[0],
tool[1],
self.fileOperations.getImageBitmap(imageName=tool[2]),
short_help_string=tool[3])
if tool[4]:
self.Bind(wx.EVT_MENU, tool[4], id=tool[0])
tb1.Realize()
return tb1
def onCollapseAll(self, event):
logger.debug('onCollapseAll')
def onLinkWithEditor(self, event):
logger.debug('onLinkWithEditor')
def onViewMenu(self, event):
logger.debug('onViewMenu')
class PythonExplorerIconManager():
def __init__(self):
self.fileOperations = FileOperations()
self.fileImageExtensionDict = {
# '.exe':'exe.png',
'.xml': 'xml.png',
'.java': 'jcu_obj.png',
'.py': 'python_module.png',
'.html': 'web.png',
'.md': 'markdown.png',
'.jar': 'jar_file.png',
'.yaml': 'yaml.png',
'.yml': 'yaml.png',
}
pass
def PopulateImageList(self, imglist):
"""Populate an ImageList with the icons for the file tree
@param imglist: wx.ImageList instance (16x16)
"""
imglist.RemoveAll()
self.iconsDictIndex = {}
count = 0
for extensionName in [
'.pdf',
'.zip',
'.xlsx',
'.xls',
'.doc',
'.ppt',
'.7z',
'.png',
'.md',
'.json',
'.docx',
'.css',
'.js',
'.bat',
'.csv',
'.txt',
'.emf',
'.rtf',
'.chm',
'.odt',
'.ini',
'.rar',
'.msi',
'.avi',
'.mp4',
'.mov',
'.flv',
'.mpg',
'.gif',
'.wma',
'.mp3',
'.wav',
'.aac',
'.m4a',
'.dmg',
'.tar',
'.gz',
]:
try:
icon = self.getIconByExtension(extensionName)
if icon:
imglist.Add(icon)
self.iconsDictIndex[extensionName] = count
self.fileImageExtensionDict[extensionName] = extensionName
count += 1
wx.LogNull()
except Exception as e:
logger.error(e, exc_info=True)
for imageName in [
'fileType_filter.png', 'folder.png', 'folder_view.png',
'harddisk.png', 'usb.png', 'stop.png', 'java.png',
'python_module.png', 'xml.png', 'python.png', 'jcu_obj.png',
'jar_file.png', 'markdown.png', 'yaml.png', 'package_obj.png',
'web.png'
]:
imglist.Add(
self.fileOperations.getImageBitmap(imageName=imageName))
self.iconsDictIndex[imageName] = count
count += 1
def getIconByExtension(self, extension=".txt"):
icon = None
noLog = wx.LogNull()
logger.debug(extension)
fileType = wx.TheMimeTypesManager.GetFileTypeFromExtension(extension)
if fileType is None:
logger.debug("File extension not found.")
else:
try:
icon, file, idx = fileType.GetIconInfo()
if icon.IsOk():
icon = icon
except:
logger.error('some error :' + extension)
# This is to supress warning
del noLog
return icon
def GetImageIndex(self, path, expanded=False):
"""Get the appropriate file index for the given path
@param path: file name or path
"""
logger.debug(f'path: {path}')
imageName = 'fileType_filter.png'
if not os.access(path, os.R_OK):
imageName = 'stop.png'
elif os.path.isdir(path):
if expanded:
imageName = 'folder_view.png'
for fname in os.listdir(path):
if fname.endswith('__init__.py'):
# do stuff on the file
imageName = 'package_obj.png'
break
else:
# do stuff if a file .true doesn't exist.
pass
else:
imageName = 'folder.png'
for fname in os.listdir(path):
if fname.endswith('__init__.py'):
# do stuff on the file
imageName = 'package_obj.png'
break
else:
# do stuff if a file .true doesn't exist.
pass
elif os.path.isfile(path):
filename, fileExtension = os.path.splitext(path)
fileExtension = fileExtension.lower()
if fileExtension and self.getFileImageNameByExtension(
fileExtension):
imageName = self.getFileImageNameByExtension(fileExtension)
return self.iconsDictIndex[imageName]
def getFileImageNameByExtension(self, fileExtension=None):
imageName = None
if fileExtension in self.fileImageExtensionDict.keys():
imageName = self.fileImageExtensionDict[fileExtension]
return imageName
class BookExplorerPanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
# self.fileOperations = FileOperations()
self.connDict = dict()
vBox = wx.BoxSizer(wx.VERTICAL)
####################################################################
self.treeMap = {}
self.fileOperations = FileOperations()
self.topToolbar = self.constructTopToolBar()
self.tree = BookExplorerTreePanel(self)
self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded)
self.tree.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed)
self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)
self.RecreateTree()
####################################################################
vBox.Add(self.topToolbar, 0, wx.EXPAND | wx.ALL)
vBox.Add(self.tree, 1, wx.EXPAND | wx.ALL)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(vBox, 1, wx.EXPAND, 0)
self.SetSizer(sizer)
def OnContextMenu(self, event):
logger.debug("OnContextMenu\n")
def constructTopToolBar(self):
# create some toolbars
tb1 = aui.AuiToolBar(self,
-1,
wx.DefaultPosition, (10, 10),
agwStyle=aui.AUI_TB_DEFAULT_STYLE
| aui.AUI_TB_OVERFLOW)
# tb1.SetToolBitmapSize(wx.Size(16, 16))
# id, name, image, name, method, kind
tools = [
(ID_COLLAPSE_ALL, "Collapse All", "collapseall-small.png",
'Collapse All', self.onCollapseAll, wx.ITEM_NORMAL),
(ID_LINK_WITH_EDITOR, "Link with Editor",
"icon_link_with_editor.png", 'Link with Editor',
self.onLinkWithEditor, wx.ITEM_CHECK),
(),
(ID_VIEW_MENU, "View Menu", "icon_menu.png", 'View Menu',
self.onViewMenu, wx.ITEM_NORMAL),
# (ID_REFRESH_ROW, "Result refresh", "resultset_refresh.png", 'Result refresh \tF5', self.onRefresh),
# (ID_ADD_ROW, "Add a new row", "row_add.png", 'Add a new row', self.onAddRow),
# (ID_DUPLICATE_ROW, "Duplicate selected row", "row_copy.png", 'Duplicate selected row', self.onDuplicateRow),
# (ID_DELETE_ROW, "Delete selected row", "row_delete.png", 'Delete selected row', self.onDeleteRow),
]
for tool in tools:
if len(tool) == 0:
tb1.AddSeparator()
else:
logger.debug(tool)
toolItem = tb1.AddSimpleTool(
tool[0],
tool[1],
self.fileOperations.getImageBitmap(imageName=tool[2]),
kind=tool[5],
short_help_string=tool[3])
if tool[4]:
self.Bind(wx.EVT_MENU, tool[4], id=tool[0])
tb1.Realize()
return tb1
def onCollapseAll(self, event):
logger.debug('onCollapseAll')
self.tree.CollapseAll()
def onLinkWithEditor(self, event):
logger.debug('onLinkWithEditor')
self.linkWithEditor = event.IsChecked()
logger.debug(f'{self.linkWithEditor}')
# event.
def onViewMenu(self, event):
logger.debug('onViewMenu')
#---------------------------------------------
def constructNode(self, parent=None, treeData=None):
logger.debug(treeData)
for treeItem in treeData:
itemId = self.tree.AppendItem(
parent,
treeItem.name,
image=self.tree.iconsDictIndex[treeItem.imageName])
self.tree.SetItemData(itemId, treeItem)
if treeItem.child:
# for childItem in treeItem.child:
self.constructNode(parent=itemId, treeData=treeItem.child)
def RecreateTree(self, evt=None):
expansionState = self.tree.GetExpansionState()
current = None
item = self.tree.GetSelection()
if item:
prnt = self.tree.GetItemParent(item)
if prnt:
current = (self.tree.GetItemText(item),
self.tree.GetItemText(prnt))
self.tree.Freeze()
self.tree.DeleteAllItems()
self.root = self.tree.AddRoot("Other View")
self.tree.SetItemImage(self.root,
self.tree.iconsDictIndex['other_view.png'])
self.tree.SetItemData(self.root, 0)
treeFont = self.tree.GetFont()
catFont = self.tree.GetFont()
# The native treectrl on MSW has a bug where it doesn't draw
# all of the text for an item if the font is larger than the
# default. It seems to be clipping the item's label as if it
# was the size of the same label in the default font.
if 'wxMSW' not in wx.PlatformInfo:
treeFont.SetPointSize(treeFont.GetPointSize() + 2)
treeFont.SetWeight(wx.BOLD)
catFont.SetWeight(wx.BOLD)
firstChild = None
selectItem = None
count = 0
treeSearch = TreeSearch()
searchText = None
treeItems = treeSearch.searchedNodes(dataList=bookExplorerList,
searchText=searchText)
self.constructNode(parent=self.root, treeData=treeItems)
if firstChild:
self.tree.Expand(firstChild)
# if filter:
# self.tree.ExpandAll()
elif expansionState:
self.tree.SetExpansionState(expansionState)
if selectItem:
self.skipLoad = True
self.tree.SelectItem(selectItem)
self.skipLoad = False
self.tree.Thaw()
self.searchItems = {}
#---------------------------------------------
def OnItemExpanded(self, event):
item = event.GetItem()
logger.debug("OnItemExpanded: %s", self.tree.GetItemText(item))
imageName = self.tree.GetItemData(item).imageName
# explandedImageName = 'eclipse_open_folder.png'
data = self.tree.GetItemData(item)
if imageName == 'user.png':
explandedImageName = 'folder_user.png'
data = self.tree.GetItemData(item)
data.imageName = explandedImageName
self.tree.SetItemData(item, data)
elif data.imageName:
explandedImageName = data.imageName
if self.tree.GetItemParent(item):
self.tree.SetItemImage(
item, self.tree.iconsDictIndex[explandedImageName])
event.Skip()
#---------------------------------------------
def OnItemCollapsed(self, event):
item = event.GetItem()
logger.debug("OnItemCollapsed: %s", self.tree.GetItemText(item))
imageName = self.tree.GetItemData(item).imageName
data = self.tree.GetItemData(item)
collapsedImageName = 'folderType_filter.png'
if imageName == 'folder_user.png':
collapsedImageName = 'user.png'
data.imageName = collapsedImageName
self.tree.SetItemData(item, data)
elif data.imageName:
collapsedImageName = data.imageName
if self.tree.GetItemParent(item):
self.tree.SetItemImage(
item, self.tree.iconsDictIndex[collapsedImageName])
event.Skip()
#---------------------------------------------
def OnTreeLeftDown(self, event):
# reset the overview text if the tree item is clicked on again
pt = event.GetPosition()
item, flags = self.tree.HitTest(pt)
if item and item == self.tree.GetSelection():
print(self.tree.GetItemText(item) + " Overview")
event.Skip()
#---------------------------------------------
def OnSelChanged(self, event):
# if self.dying or not self.loaded or self.skipLoad:
# return
# self.StopDownload()
item = event.GetItem()
try:
itemText = self.tree.GetItemText(item)
logger.debug(itemText)
opalPreference = self.GetTopLevelParent()
if opalPreference:
pnl_children = list()
if hasattr(opalPreference, 'png'):
pnl_children = opalPreference.pnl.GetChildren()
for pnl in pnl_children:
# print(pnl)
if pnl.GetName() == 'rightPanel':
opalPreference = self.GetTopLevelParent()
for child in pnl.GetChildren():
child.Hide()
rightPanelItem = opalPreference.getPreferencePanelObj(
pnl, preferenceName=itemText)
opalPreference.addPanel(rightPanelItem)
pnl.Layout()
pnl.Refresh()
pnl.Fit()
opalPreference.Layout()
if hasattr(opalPreference, 'mgr'):
opalPreference.mgr.Update()
except:
pass
class SearchPanelsFrame(wx.Frame):
def __init__(self,
parent,
Id=wx.ID_ANY,
Title="",
pos=wx.DefaultPosition,
size=wx.DefaultSize,
style=wx.DEFAULT_FRAME_STYLE | wx.SUNKEN_BORDER
| wx.STAY_ON_TOP):
style = style & (~wx.MINIMIZE_BOX)
wx.Frame.__init__(self, parent, Id, Title, pos, size, style)
self.fileOperations = FileOperations()
# pub.subscribe(self.__OnCellChange, 'OnCellChange')
self._mgr = aui.AuiManager()
# tell AuiManager to manage this frame
self._mgr.SetManagedWindow(self)
# set frame icon
icon = wx.Icon()
icon.CopyFromBitmap(
self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
# set up default notebook style
# self._mgr._autoNBStyle = aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | wx.NO_BORDER
self._notebook_theme = 0
self.BuildPanes()
self.BindEvents()
self.Show(show=True)
def BindEvents(self):
# self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
def OnCloseWindow(self, event):
self._mgr.UnInit()
event.Skip()
self.Destroy()
def OnKeyUP(self, event):
# print "KEY UP!"
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
def BuildPanes(self):
# self.SetMinSize(wx.Size(400, 300))
# this is to set tab on top
self._mgr.SetAutoNotebookStyle(aui.AUI_NB_DEFAULT_STYLE
| wx.BORDER_NONE)
self.buttonPanel = CreateButtonPanel(self)
self.fileSearchPanel = CreateFileSearchPanel(self)
fileSearchPaneInfo = aui.AuiPaneInfo().Name("fileSearch").Icon(self.fileOperations.getImageBitmap(imageName="search_history.png")).Caption("File Search")\
.Direction(wx.TOP).Row(0).Center().Layer(0).Position(0).Dockable(True)\
.CaptionVisible(False).MinimizeButton(False).CloseButton(False)
self._mgr.AddPane(self.fileSearchPanel, fileSearchPaneInfo)
self.fileSearchPanel1 = CreateFileSearchPanel(self)
self._mgr.AddPane(
self.fileSearchPanel1,
aui.AuiPaneInfo().Icon(
self.fileOperations.getImageBitmap(
imageName="search_history.png")
).Name(f"taskSearch").Caption(f"Task Search").Dockable(
False).Center().Layer(0).Position(1).CaptionVisible(
False).MinimizeButton(False).CloseButton(False),
target=fileSearchPaneInfo)
self._mgr.AddPane(
self.buttonPanel,
aui.AuiPaneInfo().Name("button").Caption("Button").Layer(0).Bottom(
).CaptionVisible(False).MinimizeButton(True).CloseButton(False))
self._mgr.Update()
class CreatingResultWithToolbarPanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self,
parent,
id=-1,
style=wx.CLIP_CHILDREN | wx.BORDER_NONE)
self.parent = parent
self.data = list()
self.pin = False
vBox = wx.BoxSizer(wx.VERTICAL)
self.fileOperations = FileOperations()
####################################################################
self.topResultToolbar = self.constructTopResultToolBar()
self.bottomResultToolbar = wx.StatusBar(self)
self.bottomResultToolbar.SetStatusText('Count: {}'.format(
len(self.getData())))
# self.bottomResultToolbar = self.constructBottomResultToolBar()
# self.resultPanel = ResultPanel(self, data=self.getData())
self.resultPanel = ResultDataGrid(self, data=self.getData())
# bottomResultToolbar = self.constructBottomResultToolBar()
####################################################################
vBox.Add(self.topResultToolbar, 0, wx.EXPAND | wx.ALL, 0)
vBox.Add(self.resultPanel, 1, wx.EXPAND | wx.ALL, 0)
vBox.Add(self.bottomResultToolbar, 0, wx.EXPAND | wx.ALL, 0)
# vBox.Add(bottomResultToolbar , 0, wx.EXPAND | wx.ALL, 0)
# vBox.Add(resultPanel , 1, wx.EXPAND | wx.ALL)
sizer = wx.BoxSizer(wx.VERTICAL)
# sizer.Add(worksheetToolbar ,.9, wx.EXPAND | wx.ALL, 0)
sizer.Add(vBox, 1, wx.EXPAND, 0)
self.SetSizer(sizer)
def constructBottomResultToolBar(self):
# tb2 = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,
# wx.TB_FLAT | wx.TB_NODIVIDER)
# str = "This is a different font."
# bottomBarText = wx.InfoBar(self)
# bottomBarText.ShowMessage("asdf")
# # tb2.AddLabelTool('asfd' bitmap=wx.Bitmap(os.path.join(imageLocation, "resultset_last.png")))
# tb2.AddTool
#
# tb2.Realize()
self.statusbar = wx.StatusBar(self).Create(self)
# self.statusbar.SetStatusText('This goes in your statusbar')
return self.statusbar
def constructTopResultToolBar(self):
# path = os.path.abspath(__file__)
# tail = None
# # head, tail = os.path.split(path)
# # print('createAuiManager',head, tail )
# try:
# while tail != 'src':
# path = os.path.abspath(os.path.join(path, '..',))
# head, tail = os.path.split(path)
# except Exception as e:
# logger.error(e, exc_info=True)
# print('------------------------------------------------------------------------->',path)
# path = os.path.abspath(os.path.join(path, "images"))
# create some toolbars
tb1 = aui.AuiToolBar(self,
-1,
wx.DefaultPosition,
wx.DefaultSize,
agwStyle=aui.AUI_TB_DEFAULT_STYLE
| aui.AUI_TB_OVERFLOW)
tb1.SetToolBitmapSize(wx.Size(42, 42))
# tb1 = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,
# wx.TB_FLAT | wx.TB_NODIVIDER)
# tb1.SetToolBitmapSize(wx.Size(16, 16))
# playImage = None
# if "worksheet" == os.path.split(os.getcwd())[-1:][0]:
# imageLocation = os.path.join("..", "..", "images")
#
# elif "view" == os.path.split(os.getcwd())[-1:][0]:
# imageLocation = os.path.join("..", "images")
tb1.AddSimpleTool(
ID_PIN,
"Pin",
self.fileOperations.getImageBitmap(imageName="pin2_green.png"),
short_help_string="Pin",
kind=ITEM_CHECK)
tb1.AddSimpleTool(ID_RUN,
"Result refresh",
self.fileOperations.getImageBitmap(
imageName="resultset_refresh.png"),
short_help_string="Refresh")
tb1.AddSimpleTool(
ID_SQL_TEXT,
"SQL \t(Ctrl+Q)",
self.fileOperations.getImageBitmap(imageName="sql_text.png"),
short_help_string="SQL \t(Ctrl+Q)")
self.Bind(wx.EVT_MENU, self.onPinClick, id=ID_PIN)
self.Bind(wx.EVT_MENU, self.onSqlText, id=ID_SQL_TEXT)
tb1.AddSeparator()
tb1.Realize()
return tb1
def onSqlText(self, event):
logger.debug(f'onSqlText:{self.resultPanel.sqlText}')
frame = SqlQueryFrame(self,
sqlText=self.resultPanel.sqlText,
size=(400, 300))
frame.CenterOnScreen()
def onPinClick(self, event):
logger.debug(f'onPinClick:{self.pin}')
self.pin = not self.pin
def getData(self):
# Get the data from the ListCtrl sample to play with, converting it
# from a dictionary to a list of lists, including the dictionary key
# as the first element of each sublist.
# self.data=music
return self.data
class DatabaseNavigationTree(ExpansionState, TreeCtrl):
'''
Left navigation tree in database page
'''
def __init__(self, parent):
TreeCtrl.__init__(self,
parent,
style=wx.TR_DEFAULT_STYLE
| wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.TR_HIDE_ROOT)
self.BuildTreeImageList()
# if USE_CUSTOMTREECTRL:
# self.SetSpacing(10)
# self.SetWindowStyle(self.GetWindowStyle() & ~wx.TR_LINES_AT_ROOT)
self.eventdict = {
# 'EVT_TREE_BEGIN_DRAG': self.OnBeginDrag, 'EVT_TREE_BEGIN_LABEL_EDIT': self.OnBeginEdit,
# 'EVT_TREE_BEGIN_RDRAG': self.OnBeginRDrag, 'EVT_TREE_DELETE_ITEM': self.OnDeleteItem,
# 'EVT_TREE_END_DRAG': self.OnEndDrag, 'EVT_TREE_END_LABEL_EDIT': self.OnEndEdit,
# 'EVT_TREE_ITEM_ACTIVATED': self.OnActivate, 'EVT_TREE_ITEM_CHECKED': self.OnItemCheck,
# 'EVT_TREE_ITEM_CHECKING': self.OnItemChecking, 'EVT_TREE_ITEM_COLLAPSED': self.OnItemCollapsed,
# 'EVT_TREE_ITEM_COLLAPSING': self.OnItemCollapsing, 'EVT_TREE_ITEM_EXPANDED': self.OnItemExpanded,
# 'EVT_TREE_ITEM_EXPANDING': self.OnItemExpanding, 'EVT_TREE_ITEM_GETTOOLTIP': self.OnToolTip,
# 'EVT_TREE_ITEM_MENU': self.OnItemMenu, 'EVT_TREE_ITEM_RIGHT_CLICK': self.OnRightDown,
'EVT_TREE_KEY_DOWN': self.OnKey,
# 'EVT_TREE_SEL_CHANGED': self.OnSelChanged,
# 'EVT_TREE_SEL_CHANGING': self.OnSelChanging, "EVT_TREE_ITEM_HYPERLINK": self.OnHyperLink
}
self.SetInitialSize((100, 80))
def AppendItem(self, parent, text, image=-1, wnd=None):
item = TreeCtrl.AppendItem(self, parent, text, image=image)
return item
#---------------------------------------------
def OnKey(self, event):
logger.debug('onkey')
keycode = event.GetKeyCode()
keyname = keyMap.get(keycode, None)
if keycode == wx.WXK_BACK:
self.log.write(
"OnKeyDown: HAHAHAHA! I Vetoed Your Backspace! HAHAHAHA\n")
return
if keyname is None:
if "unicode" in wx.PlatformInfo:
keycode = event.GetUnicodeKey()
if keycode <= 127:
keycode = event.GetKeyCode()
keyname = "\"" + event.GetUnicodeKey() + "\""
if keycode < 27:
keyname = "Ctrl-%s" % chr(ord('A') + keycode - 1)
elif keycode < 256:
if keycode == 0:
keyname = "NUL"
elif keycode < 27:
keyname = "Ctrl-%s" % chr(ord('A') + keycode - 1)
else:
keyname = "\"%s\"" % chr(keycode)
else:
keyname = "unknown (%s)" % keycode
self.log.write("OnKeyDown: You Pressed '" + keyname + "'\n")
event.Skip()
def BuildTreeImageList(self):
imgList = wx.ImageList(16, 16)
self.fileOperations = FileOperations()
# add the image for modified demos.
imgList.Add(
self.fileOperations.getImageBitmap(imageName="database.png")) # 0
imgList.Add(
self.fileOperations.getImageBitmap(
imageName="database_category.png")) # 1
imgList.Add(
self.fileOperations.getImageBitmap(
imageName="folder_view.png")) # 2
imgList.Add(
self.fileOperations.getImageBitmap(imageName="folder.png")) # 3
imgList.Add(
self.fileOperations.getImageBitmap(imageName="table.png")) # 4
imgList.Add(
self.fileOperations.getImageBitmap(imageName="view.png")) # 5
imgList.Add(
self.fileOperations.getImageBitmap(imageName="index.png")) # 6
imgList.Add(self.fileOperations.getImageBitmap(
imageName="column.png")) # 7 using to show integer column
imgList.Add(
self.fileOperations.getImageBitmap(imageName="string.png")) # 8
imgList.Add(
self.fileOperations.getImageBitmap(imageName="key.png")) # 9
imgList.Add(
self.fileOperations.getImageBitmap(
imageName="foreign_key_column.png")) # 10
imgList.Add(
self.fileOperations.getImageBitmap(imageName="columns.png")) # 11
imgList.Add(
self.fileOperations.getImageBitmap(
imageName="unique_constraint.png")) # 12
imgList.Add(
self.fileOperations.getImageBitmap(
imageName="reference.png")) # 13
imgList.Add(
self.fileOperations.getImageBitmap(imageName="datetime.png")) # 14
imgList.Add(
self.fileOperations.getImageBitmap(imageName="columns.png")) # 15
imgList.Add(
self.fileOperations.getImageBitmap(imageName="sqlite.png")) # 16
imgList.Add(self.fileOperations.getImageBitmap(
imageName="h2.png")) # 17 use to show h2 database icon
imgList.Add(
self.fileOperations.getImageBitmap(imageName="textfield.png")
) # 18 use to show [varchar, char, text data] type icon
# imgList.Add(wx.Bitmap(path2))
# for png in _demoPngs:
# imgList.Add(catalog[png].GetBitmap())
self.AssignImageList(imgList)
def GetItemIdentity(self, item):
return self.GetPyData(item)
def Freeze(self):
if 'wxMSW' in wx.PlatformInfo:
return super(DatabaseNavigationTree, self).Freeze()
def Thaw(self):
if 'wxMSW' in wx.PlatformInfo:
return super(DatabaseNavigationTree, self).Thaw()
class CreateResultSheetTabPanel(wx.Panel):
def __init__(self, parent=None, *args, **kw):
wx.Panel.__init__(self, parent, id=-1)
self.parent = parent
self.fileOperations = FileOperations()
# Attributes
self._nb = aui.AuiNotebook(self)
# if "worksheet" == os.path.split(os.getcwd())[-1:][0]:
# imageLocation = os.path.join("..", "..", "images")
# # playImage=wx.Bitmap(os.path.join("..","..", "images", "play.png"))
# elif "view" == os.path.split(os.getcwd())[-1:][0]:
# imageLocation = os.path.join(path)
imgList = wx.ImageList(16, 16)
imgList.Add(self.fileOperations.getImageBitmap("sql_script.png"))
self._nb.AssignImageList(imgList)
self.addTab()
# self._nb.AddPage(worksheetPanel, "2", imageId=0)
# Layout
self.__DoLayout()
def addTab(self, name='Start Page'):
resultSheetPanel = CreatingResultWithToolbarPanel(
self._nb, -1, style=wx.CLIP_CHILDREN | wx.BORDER_NONE)
# worksheetPanel.worksheetPanel.editorPanel
name = 'Query Result '
self._nb.AddPage(resultSheetPanel, name)
self._nb.SetSelectionToWindow(resultSheetPanel)
self.Bind(aui.EVT_AUINOTEBOOK_TAB_RIGHT_DOWN, self.onTabRightDown,
self._nb)
self.Bind(aui.EVT_AUINOTEBOOK_BG_DCLICK, self.onBgDoubleClick,
self._nb)
self.Bind(aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.onCloseClick, self._nb)
def __DoLayout(self):
"""Layout the panel"""
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self._nb, 1, wx.EXPAND)
self.SetAutoLayout(True)
self.SetSizer(sizer)
self.Layout()
def SetCurrentPage(self, page):
"""
Set the current page to the page given
"""
n = self._nb.GetPageIndex(page)
if n != -1:
self._nb.SetSelection(n)
return True
return False
def GetCurrentPage(self):
"""
Get the current active Page page
"""
num = self._nb.GetSelection()
if num == -1:
page = None
else:
page = self._nb.GetPage(num)
return page
def GetPages(self, page_type):
"""
Get all the Page pages of a particular type
"""
npages = self._nb.GetPageCount()
res = []
for n in range(0, npages):
page = self._nb.GetPage(n)
if isinstance(page, page_type):
res.append(page)
return res
def onTabRightDown(self, event):
logger.debug('onTabRightDown')
def onBgDoubleClick(self, event):
logger.debug('onBgDoubleClick')
def onCloseClick(self, event):
logger.debug('onCloseClick')
self.GetCurrentPage()
class Preference(wx.Frame):
def __init__(self, parent, title, size=(700, 440)):
wx.Frame.__init__(self,
parent,
-1,
title,
size=size,
style=wx.DEFAULT_FRAME_STYLE
| wx.NO_FULL_REPAINT_ON_RESIZE)
self.Center()
# self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
self.allowAuiFloating = False
self.SetMinSize((640, 480))
self.fileOperations = FileOperations()
icon = wx.Icon()
icon.CopyFromBitmap(
self.fileOperations.getImageBitmap(imageName='eclipse16.png'))
self.SetIcon(icon)
self._mgr = aui.AuiManager()
# tell AuiManager to manage this frame
self._mgr.SetManagedWindow(self)
self.BuildPanes()
self.BindEvents()
self.Show()
def OnKeyUP(self, event):
# print "KEY UP!"
keyCode = event.GetKeyCode()
if keyCode == wx.WXK_ESCAPE:
self.Close()
event.Skip()
def OnCloseFrame(self, event):
self.Destroy()
def OnSize(self, event):
hsize = event.GetSize()
logger.debug(hsize)
def BindEvents(self):
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUP)
def BuildPanes(self):
self.SetMinSize(wx.Size(700, 440))
# add a bunch of panes
self._mgr.AddPane(
self.createPreferenceTree(),
aui.AuiPaneInfo().Name("left").Caption("Pane Caption").BestSize(
wx.Size(200, 100)).CaptionVisible(
False, left=False).Left().MinimizeButton(True))
# .MinSize(wx.Size(200,100))
self._mgr.AddPane(
self.rightPanel(),
aui.AuiPaneInfo().Name("center").Caption("Client Size Reporter").
Center().Position(1).CloseButton(True).MaximizeButton(
True).MinimizeButton(True).CaptionVisible(False, left=False))
self._mgr.AddPane(
self.bottomPanel(),
aui.AuiPaneInfo().Name("bottom").Caption("Client Size Reporter").
BestSize(wx.Size(200, 40)).MinSize(wx.Size(200, 40)).MaxSize(
wx.Size(
200,
40)).Bottom().Position(0).CloseButton(True).MaximizeButton(
True).MinimizeButton(True).CaptionVisible(False,
left=False))
self._mgr.Update()
def createPreferenceTree(self):
prefrencesTreePanel = PrefrencesTreePanel(self)
return prefrencesTreePanel
def CreateSizeReportCtrl(self, width=80, height=80):
ctrl = SizeReportCtrl(self, -1, wx.DefaultPosition,
wx.Size(width, height), self._mgr)
return ctrl
def rightPanel(self):
ctrl = RightPanel(self, -1, wx.DefaultPosition)
return ctrl
def bottomPanel(self):
applyResetButtonPanel = ApplyCloseButtonPanel(self)
return applyResetButtonPanel
class ResultDataGrid(gridlib.Grid):
def __init__(self, parent, model=None, data=None):
gridlib.Grid.__init__(self, parent, -1, style=wx.BORDER_NONE)
self.fileOperations = FileOperations()
self.CreateGrid(0, 0)
self.RowLabelSize = 32
self.Bind(gridlib.EVT_GRID_CELL_RIGHT_CLICK, self.showGridCellPopupMenu)
self.Bind(gridlib.EVT_GRID_LABEL_RIGHT_CLICK, self.showHeaderPopupMenu)
self.Bind(wx.EVT_KEY_DOWN, self.OnKey)
self.Bind(gridlib.EVT_GRID_CELL_CHANGED, self.cellChange)
self.data = None
self.sqlText = ''
# self.SetCellAlignment(row, col, horiz, vert)
# Somebody changed the grid so the type registry takes precedence
# over the default attribute set for editors and renderers, so we
# have to set null handlers for the type registry before the
# default editor will get used otherwise...
# self.RegisterDataType(wxGRID_VALUE_STRING, None, None)
# self.SetDefaultEditor(MyCellEditor())
# Or we could just do it like this:
# self.RegisterDataType(wx.GRID_VALUE_STRING,
# wx.GridCellStringRenderer(),
# MyCellEditor())
# )
# but for this example, we'll just set the custom editor on one cell
# self.SetCellEditor(1, 0, MyCellEditor())
# self.SetCellValue(1, 0, "Try to edit this box")
#
# # and on a column
# attr = gridlib.GridCellAttr()
# attr.SetEditor(MyCellEditor())
# self.SetColAttr(2, attr)
# self.SetCellValue(1, 2, "or any in this column")
#
# self.addData()
def setSqlText(self, sqlText):
self.sqlText = sqlText
def setData(self, data):
self.data = data
def getData(self):
return self.data
def cellChange(self, evt):
row = evt.GetRow()
col = evt.GetCol()
# #print 'Cell changed at', row, col
value = self.GetTable().GetValue(row, col)
logger.info(f'cellChange ({row,col}):{value}')
# #print 'New value', value
# #print 'Type', type(value)
evt.Skip()
return
def addData(self, data=None):
self.data = data
# logger.info(self.GetRowSizes())
# logger.info(self.GetColSizes())
self.ClearGrid()
try:
if data and len(data) > 0:
dataTypeRow = data.get(-1)
# logger.info('rows:', self.GetNumberRows())
# logger.info('cols:', self.GetNumberCols())
# self.DeleteRows()
currentRows, currentCols = (self.GetNumberRows(), self.GetNumberCols())
newRows = len(data) - 1
if dataTypeRow:
newRows = newRows - 1
newCols = len(data[0])
# self.AppendRows(numRows=len(data)-1, updateLabels=True)
# if len(data) > 0 :
# self.AppendCols(numCols=len(data[0]), updateLabels=True)
if newRows < currentRows:
# - Delete rows:
self.DeleteRows(0, currentRows - newRows, True)
if newRows > currentRows:
# - append currentRows:
self.AppendRows(newRows - currentRows)
if newCols < currentCols:
# - Delete rows:
self.DeleteCols(pos=0, numCols=currentCols - newCols, updateLabels=True)
if newCols > currentCols:
# - append currentRows:
self.AppendCols(newCols - currentCols)
for dataKey, dataValue in data.items():
# logger.info(dataKey, dataValue)
for idx, colValue in enumerate(dataValue):
# logger.info(idx, dataValue)
if dataKey == 0:
self.SetColLabelValue(idx, str(colValue))
elif dataKey > 0:
row = dataKey - 1
col = idx
try:
# if col==3:
# size=self.GetCellSize(row, col)
# data='3.jpg'
# self.SetCellRenderer(row, col, MegaImageRenderer(self.GetTable(), data))
# elif str(colValue).startswith('-______-'):
if str(colValue).startswith('-______-'):
newStringValue = str(colValue).replace('-______-', '')
self.SetCellFont(row, col, wx.Font(10, wx.FONTFAMILY_SCRIPT, wx.FONTSTYLE_ITALIC, wx.FONTWEIGHT_NORMAL))
self.SetCellTextColour(row, col, wx.LIGHT_GREY)
self.SetCellValue(row, col, newStringValue)
else:
if dataTypeRow and dataTypeRow[col].lower() == 'blob':
# data='3.jpg'
if str(colValue).startswith('-______-'):
newStringValue = str(colValue).replace('-______-', '')
self.SetCellFont(row, col, wx.Font(10, wx.FONTFAMILY_SCRIPT, wx.FONTSTYLE_ITALIC, wx.FONTWEIGHT_NORMAL))
self.SetCellTextColour(row, col, wx.LIGHT_GREY)
self.SetCellValue(row, col, newStringValue)
else:
self.SetCellRenderer(row, col, MegaImageRenderer(self.GetTable(), colValue))
elif dataTypeRow and dataTypeRow[col].lower() == 'integer':
self.SetCellRenderer(row, col, gridlib.GridCellNumberRenderer())
self.SetCellValue(row, col, str(colValue))
elif dataTypeRow and dataTypeRow[col].lower() == 'datetime':
self.SetCellRenderer(row, col, gridlib.GridCellDateTimeRenderer())
self.SetCellValue(row, col, colValue)
elif dataTypeRow and dataTypeRow[col].lower() == 'boolean':
self.SetCellEditor(row, col, gridlib.GridCellBoolEditor())
self.SetCellRenderer(row, col, CheckBoxCellRenderer(self))
self.SetCellValue(row, col, str(colValue))
self.SetCellAlignment(row, col, wx.ALIGN_RIGHT, wx.ALIGN_CENTRE)
# elif dataTypeRow and dataTypeRow[col] in ['varchar', 'int']:
else:
# self.SetCellFont(dataKey - 1, idx, wx.Font(10, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_ITALIC, wx.FONTWEIGHT_NORMAL))
# self.SetCellTextColour(dataKey - 1, idx,wx.LIGHT_GREY)
self.SetCellValue(row, col, str(colValue))
# self.SetCellAlignment(dataKey - 1,idx, wx.ALIGN_RIGHT)
except Exception as e:
logger.error(e, exc_info=True)
else:
numCols = self.GetNumberCols()
numRows = self.GetNumberRows()
logger.debug("numRows:%s, numCol: %s", numRows, numCols)
if numRows > 0 and numCols > 0:
self.DeleteCols(pos=0, numCols=numCols, updateLabels=True)
self.DeleteRows(pos=0, numRows=numRows, updateLabels=True)
except Exception as e:
logger.error(e, exc_info=True)
self.Refresh()
# self.SetColSize(0, 150)
# self.SetColSize(1, 150)
# self.SetColSize(2, 150)
def selection(self):
# Show cell selection
# If selection is cell...
if self.GetSelectedCells():
logger.info("Selected cells " + str(self.GetSelectedCells()))
# If selection is block...
if self.GetSelectionBlockTopLeft():
logger.info("Selection block top left " + str(self.GetSelectionBlockTopLeft()))
if self.GetSelectionBlockBottomRight():
logger.info("Selection block bottom right " + str(self.GetSelectionBlockBottomRight()))
# If selection is col...
if self.GetSelectedCols():
logger.info("Selected cols " + str(self.GetSelectedCols()))
# If selection is row...
if self.GetSelectedRows():
logger.info("Selected rows " + str(self.GetSelectedRows()))
def currentcell(self):
# Show cursor position
row = self.GetGridCursorRow()
col = self.GetGridCursorCol()
cell = (row, col)
logger.info("Current cell " + str(cell))
return row, col
def OnKey(self, event):
# If Ctrl+C is pressed...
if event.ControlDown() and event.GetKeyCode() == 67:
logger.info("Ctrl+C")
self.selection()
# Call copy method
self.copy()
# If Ctrl+V is pressed...
if event.ControlDown() and event.GetKeyCode() == 86:
logger.info("Ctrl+V")
self.currentcell()
# Call paste method
self.paste()
# If Ctrl+Z is pressed...
if event.ControlDown() and event.GetKeyCode() == 90:
if self.data4undo[2] != '':
self.paste('undo')
# If Supr is presed
if event.GetKeyCode() == 127:
logger.info("Supr")
# Call delete method
self.delete()
# Skip other Key events
if event.GetKeyCode():
event.Skip()
return
def delete(self):
'''This method deletes text from selected cells, places a
copy of the deleted cells on the clipboard for pasting
(Ctrl+v), and places a copy in the self.data4undo variable
for undoing (Ctrl+z)
'''
# Get number of delete rows and cols
if self.GetSelectionBlockTopLeft() == []:
rowstart = self.GetGridCursorRow()
colstart = self.GetGridCursorCol()
rowend = rowstart
colend = colstart
else:
rowstart = self.GetSelectionBlockTopLeft()[0][0]
colstart = self.GetSelectionBlockTopLeft()[0][1]
rowend = self.GetSelectionBlockBottomRight()[0][0]
colend = self.GetSelectionBlockBottomRight()[0][1]
rows = rowend - rowstart + 1
cols = colend - colstart + 1
# Save deleted text and clear cells contents
text4undo = ''
for r in range(rows):
for c in range(cols):
text4undo += \
str(self.GetCellValue(rowstart + r, colstart + c)) + '\t'
self.SetCellValue(rowstart + r, colstart + c, '')
text4undo = text4undo[:-1] + '\n'
# Save a copy of deleted text for undo
self.data4undo = [rowstart, colstart, text4undo]
# Save a copy of deleted text to clipboard for Ctrl+v
clipboard = wx.TextDataObject()
clipboard.SetText(text4undo)
if wx.TheClipboard.Open():
wx.TheClipboard.SetData(clipboard)
wx.TheClipboard.Close()
else:
wx.MessageBox("Can't open the clipboard", "Error")
def copy(self):
logger.info("Copy method")
data = None
# Number of rows and cols
if len(self.GetSelectionBlockBottomRight()) > 0:
data = ''
rows = self.GetSelectionBlockBottomRight()[0][0] - self.GetSelectionBlockTopLeft()[0][0] + 1
cols = self.GetSelectionBlockBottomRight()[0][1] - self.GetSelectionBlockTopLeft()[0][1] + 1
# data variable contain text that must be set in the clipboard
# For each cell in selected range append the cell value in the data variable
# Tabs '\t' for cols and '\r' for rows
for r in range(rows):
for c in range(cols):
data = data + str(self.GetCellValue(self.GetSelectionBlockTopLeft()[0][0] + r, self.GetSelectionBlockTopLeft()[0][1] + c))
if c < cols - 1:
data = data + '\t'
data = data + '\n'
else:
# setting the current cell value
data = self.GetCellValue(self.GridCursorRow, self.GridCursorCol)
if data:
self.createClipboardData(data)
def createClipboardData(self, data):
# Create text data object
clipboard = wx.TextDataObject()
# Set data object value
clipboard.SetText(data)
# Put the data in the clipboard
if wx.TheClipboard.Open():
wx.TheClipboard.SetData(clipboard)
wx.TheClipboard.Close()
else:
wx.MessageBox("Can't open the clipboard", "Error")
def paste(self):
logger.info("Paste method")
clipboard = wx.TextDataObject()
if wx.TheClipboard.Open():
wx.TheClipboard.GetData(clipboard)
wx.TheClipboard.Close()
else:
wx.MessageBox("Can't open the clipboard", "Error")
data = clipboard.GetText()
table = []
y = -1
# Convert text in a array of lines
for r in data.splitlines():
y = y + 1
x = -1
# Convert c in a array of text separated by tab
for c in r.split('\t'):
x = x + 1
self.SetCellValue(self.GetGridCursorRow() + y, self.GetGridCursorCol() + x, c)
#----------------------------------------------------------------------
def onCellEdit(self, event):
'''
When cell is edited, get a handle on the editor widget
and bind it to EVT_KEY_DOWN
'''
editor = event.GetControl()
editor.Bind(wx.EVT_KEY_DOWN, self.onEditorKey)
event.Skip()
#----------------------------------------------------------------------
def onEditorKey(self, event):
'''
Handler for the wx.grid's cell editor widget's keystrokes. Checks for specific
keystrokes, such as arrow up or arrow down, and responds accordingly. Allows
all other key strokes to pass through the handler.
'''
keycode = event.GetKeyCode()
if keycode == wx.WXK_UP:
logger.info('you pressed the UP key!')
self.grid.MoveCursorUp(False)
elif keycode == wx.WXK_DOWN:
logger.info('you pressed the down key!')
self.grid.MoveCursorDown(False)
elif keycode == wx.WXK_LEFT:
logger.info('you pressed the left key!')
self.grid.MoveCursorLeft(False)
elif keycode == wx.WXK_RIGHT:
logger.info('you pressed the right key')
self.grid.MoveCursorRight(False)
else:
pass
event.Skip()
#----------------------------------------------------------------------
def showHeaderPopupMenu(self, event):
"""
Create and display a popup menu on right-click event
"""
row, col = event.GetRow(), event.GetCol()
if row == -1: self.colPopup(col, event)
elif col == -1: self.rowPopup(row, event)
# if col>=0:
# header = self.GetColLabelValue(event.GetCol())
# menu = GridHeaderPopupMenu(header=header)
# self.PopupMenu(menu, event.GetPosition())
# menu.Destroy()
def rowPopup(self, row, evt):
"""(row, evt) -> display a popup menu when a row label is right clicked"""
menu = wx.Menu()
self = self
copyID = wx.NewIdRef()
appendID = wx.NewIdRef()
deleteID = wx.NewIdRef()
x = self.GetRowSize(row) / 2
copyRowItem = wx.MenuItem(menu, copyID, "Copy Row")
copyRowItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="copy_edit_co.png"))
copyItemMenu = menu.Append(copyRowItem)
appendRowItem = wx.MenuItem(menu, appendID, "Append Row")
appendRowItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="row_add.png"))
appendItemMenu = menu.Append(appendRowItem)
# self.Bind(wx.EVT_MENU, lambda e: self.onCopySelection(e), copyItemMenu)
if not self.GetSelectedRows():
self.SelectRow(row)
xo, yo = evt.GetPosition()
# menu.Append(appendID, "Append Row")
deleteRowsItem = wx.MenuItem(menu, deleteID, "Delete Row(s)")
deleteRowsItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="row_delete.png"))
deleteItemMenu = menu.Append(deleteRowsItem)
# menu.Append(deleteID, "Delete Row(s)")
def copy(event, self=self, row=row):
logger.debug(row)
# self.AppendRows(row)
selection = self.get_selection()
if not selection:
return []
start_row, start_col, end_row, end_col = selection
data = u''
rows = range(start_row, end_row + 1)
for row in rows:
columns = range(start_col, end_col + 1)
for idx, column in enumerate(columns, 1):
if idx == len(columns):
# if we are at the last cell of the row, add new line instead
data += self.GetCellValue(row, column) + "\n"
else:
data += self.GetCellValue(row, column) + "\t"
text_data_object = wx.TextDataObject()
text_data_object.SetText(data)
if wx.TheClipboard.Open():
wx.TheClipboard.SetData(text_data_object)
wx.TheClipboard.Close()
else:
wx.MessageBox("Can't open the clipboard", "Warning")
def append(event, self=self, row=row):
logger.debug('append')
# self.AppendRows(row)
self.AppendRows(numRows=1, updateLabels=True)
def delete(event, self=self, row=row):
logger.debug(row)
rows = self.GetSelectedRows()
for row in rows:
self.DeleteRows(pos=row, numRows=1, updateLabels=True)
# self.DeleteRows(pos=0, numRows=1, updateLabels=True)
self.Bind(wx.EVT_MENU, lambda e:copy(e, row=1), id=copyID)
self.Bind(wx.EVT_MENU, lambda e:append(e, row=1), id=appendID)
self.Bind(wx.EVT_MENU, lambda e:delete(e, row=[0]), id=deleteID)
self.PopupMenu(menu)
menu.Destroy()
return
def get_selection(self):
"""
Returns selected range's start_row, start_col, end_row, end_col
If there is no selection, returns selected cell's start_row=end_row, start_col=end_col
"""
if not len(self.GetSelectionBlockTopLeft()):
selected_columns = self.GetSelectedCols()
selected_rows = self.GetSelectedRows()
if selected_columns:
start_col = selected_columns[0]
end_col = selected_columns[-1]
start_row = 0
end_row = self.GetNumberRows() - 1
elif selected_rows:
start_row = selected_rows[0]
end_row = selected_rows[-1]
start_col = 0
end_col = self.GetNumberCols() - 1
else:
start_row = end_row = self.GetGridCursorRow()
start_col = end_col = self.GetGridCursorCol()
elif len(self.GetSelectionBlockTopLeft()) > 1:
wx.MessageBox("Multiple selections are not supported", "Warning")
return []
else:
start_row, start_col = self.GetSelectionBlockTopLeft()[0]
end_row, end_col = self.GetSelectionBlockBottomRight()[0]
return [start_row, start_col, end_row, end_col]
def get_selected_cells(self):
# returns a list of selected cells
selection = self.get_selection()
if not selection:
return
start_row, start_col, end_row, end_col = selection
for row in range(start_row, end_row + 1):
for col in range(start_col, end_col + 1):
yield [row, col]
def colPopup(self, col, evt):
"""(col, evt) -> display a popup menu when a column label is
right clicked"""
x = self.GetColSize(col) / 2
menu = wx.Menu()
copyHeaderId = wx.NewIdRef()
sortID = wx.NewIdRef()
xo, yo = evt.GetPosition()
self.SelectCol(col)
cols = self.GetSelectedCols()
header = self.GetColLabelValue(col)
self.Refresh()
copyHeaderItem = wx.MenuItem(menu, copyHeaderId, "Copy Selected Header")
copyHeaderItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="copy_edit_co.png"))
copyHeaderMenu = menu.Append(copyHeaderItem)
sortHeaderItem = wx.MenuItem(menu, sortID, "Sort Column")
sortHeaderItem.SetBitmap(self.fileOperations.getImageBitmap(imageName="sort.png"))
sortHeaderMenu = menu.Append(sortHeaderItem)
# menu.Append(copyHeaderId, "Copy Selected Header")
# menu.Append(sortID, "Sort Column")
# self.header = header
# item = wx.MenuItem(self, wx.NewIdRef(), "Sort...")
# self.Append(item)
# self.Bind(wx.EVT_MENU, self.OnSortColumn, item)
#
# item = wx.MenuItem(self, wx.NewIdRef(), "Copy Selected Header")
# self.Append(item)
# self.Bind(wx.EVT_MENU, self.OnItem3, item)
def delete(event, self=self, col=col):
cols = self.GetSelectedCols()
self._table.DeleteCols(cols)
logger.info('TODO delete')
self.Reset()
def sort(event, self=self, col=col):
logger.info(f'TODO started sorting{col}: {self.IsSortOrderAscending()} :{self.GetSortingColumn()}')
self.IsSortOrderAscending()
self.SetSortingColumn(col, ascending=True)
# self._table.SortColumn(col)
# self.Reset()
def copyColumnName(event, self=self, header=header):
""""""
self.dataObj = wx.TextDataObject()
self.dataObj.SetText(header)
if wx.TheClipboard.Open():
wx.TheClipboard.SetData(self.dataObj)
wx.TheClipboard.Close()
else:
wx.MessageBox("Unable to open the clipboard", "Error")
# self.header = header
pass
self.Bind(wx.EVT_MENU, copyColumnName, id=copyHeaderId)
if len(cols) == 1:
self.Bind(wx.EVT_MENU, lambda e:sort(e, col=cols[0]), id=sortID)
self.PopupMenu(menu)
menu.Destroy()
return
#----------------------------------------------------------------------
def showGridCellPopupMenu(self, event):
"""
Create and display a popup menu on right-click event
"""
menu = GridCellPopupMenu(self)
self.PopupMenu(menu, event.GetPosition())
menu.Destroy()