def _element_selected(self, elementId, notify=True):
log.log("StructureRegisterBrowser._element_selected", [elementId, notify], 0)
if self.__ficheLevel:
RegisterBrowser._element_selected(self, elementId, notify=notify)
else:
self.__element = self.__register.getNodeById(elementId)
log.log("StructureRegisterBrowser._element_selected return", [self.__element], 1)
def reset(self):
log.log("WindowRegisterBrowser.reset", [], 0)
RegisterBrowser.reset(self)
self._window = 0
self._windowVeto = False
# czy self._reg = None cos psuje?
log.log("WindowRegisterBrowser.reset return", [], 1)
def prevBinaryAcceptPrepare(self, automatic=False): log.log(["prevBinaryAcceptPrepare", self.__selectedElement, self.__binaryType]) #print "!", self.__left, self.__center, self.__right # #print ":", self.__left, self.__right if self.__left == self.__right: if not automatic: for l in self._listeners: l.stop_binary_search() return False # self.__right = self.__center - 1 if self.__right < self.__left: self.__right = self.__left if not self.__binaryScopeValid: # TODO: A po co? self.__binaryScopeValid = True self.__rightFiche = self.__potentialPrevRightFiche if self.__right == self.__left: return False self.__center = self.__potentialPrevCenter self.__centerFiche = self.__potentialPrevCenterFiche return True if self.__binaryType == "GAP": self.__rightFiche = self.__dBController.getFicheForGapPosition(self.__selectedElement[1], self.__selectedElement[2], self.__right) else: self.__rightFiche = self.__dBController.getFicheForEntryPosition(self.__selectedElement, self.__right) return self.__selectCenterPrepare()
def __binaryFind(self, what):
log.log("HintRegisterBrowser.__binaryFind", [what], 0)
collator = icu.Collator.createInstance(icu.Locale('pl_PL.UTF-8'))
def __pom(left, right):
if left == right:
if collator.compare(anyHint(self.__hints[left]), what) > 0:
return left
else:
return left + 1
elif left + 1 == right:
if collator.compare(anyHint(self.__hints[left]), what) > 0:
return left
elif collator.compare(anyHint(self.__hints[right]), what) > 0:
return right
else:
return right + 1
lenn = right - left
center = left + lenn // 2
if collator.compare(anyHint(self.__hints[center]), what) > 0:
return __pom(left, center - 1)
else:
return __pom(center + 1, right)
res = __pom(0, len(self.__hints) - 1)
log.log("HintRegisterBrowser.__binaryFind return", [res], 1)
return res
def nextBinary(self):
log.log("RegisterBrowser.nextBinary", [], 0)
self.__left = self.__center
self.SetStringItem(self.__center, 2, ">") # zaznacz historie wyszukiwania
self.__markScope()
self.__selectCenter()
log.log("RegisterBrowser.nextBinary return", [], 1)
def focusAndSelect(self):
log.log("focusAndSelect", [], 0)
def __pom():
self.__editPanel.SetSelection(-1, -1)
wx.CallAfter(__pom)
self.__editPanel.SetFocus()
log.log("focusAndSelect return", [], 1)
def DeleteAllItems(self):
log.log("RegisterBrowser.DeleteAllItems", [], 0)
wx.ListCtrl.DeleteAllItems(self)
self._items = []
self._item2element = {} # mapowanie z identyfikatorow elementow na identyfikatory fiszek
self._element2item = {} # vice versa
log.log("RegisterBrowser.DeleteAllItems return", [], 1)
def _element_selected(self, elementId, notify=True):
log.log("EntryRegisterBrowser._element_selected", [elementId, notify, self.__level], 0)
if self.__level == "FICHE":
RegisterBrowser._element_selected(self, elementId, notify=notify)
else:
self.__selectedElement = elementId
log.log("EntryRegisterBrowser._element_selected return", [], 1)
def reset(self):
log.log("EntryRegisterBrowser.reset", [], 0)
RegisterBrowser.reset(self)
self.__level = "ENTRY"
self.__stack = []
self.__selectedElement = None
log.log("EntryRegisterBrowser.reset return", [], 1)
def _scrollBrowser(self, itemId):
#mapsafe
#print itemId, stru(self._elementLabels[itemId]), stru(self._elements[itemId])
#self.__check()
log.log("WindowRegisterBrowser._scrollBrowser", [itemId, self._window],
0)
wx.ListCtrl.DeleteAllItems(self)
halfBefore = self.LIMIT() / 2
halfAfter = self.LIMIT() - halfBefore
if itemId + halfAfter > self._itemsLen(): #len(self._items):
halfBefore += itemId + halfAfter - self._itemsLen(
) #len(self._items)
halfAfter -= itemId + halfAfter - self._itemsLen(
) #len(self._items)
elif itemId - halfBefore < 0:
halfAfter += halfBefore - itemId
halfBefore -= halfBefore - itemId
#print itemId, self._window, self.__len
#print halfBefore, halfAfter
for i in range(0, self.LIMIT()):
self.InsertStringItem(
i, self._shownLabel(self._reg[itemId - halfBefore + i]))
self.SetStringItem(i, 1, "")
self.SetStringItem(i, 2, "")
self.SetStringItem(
i, 3,
self._secondColumn(self._reg[itemId - halfBefore + i],
self.__entryGetter))
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
self.SetColumnWidth(3, wx.LIST_AUTOSIZE)
self._window = itemId - halfBefore
log.log("WindowRegisterBrowser.setRegister return", [self._window], 1)
def stopBinarySearch(self): log.log(["stopBinarySearch", self.__selectedElement, self.__binaryType]) self._binary = False #print "@", restart #print "restartujemy?" #print restart, self.__binaryTarget, self.__leftTargetBinary #if restart and self.__binaryTarget != None and self.__firstIndexedFicheEntry == self.__binaryTarget and self.__leftTargetBinary: #:if restart and self.__binaryTarget != None and self.__leftTargetBinary: #print "in" #print "restartujemy!" #:itemId = self.FindItem(-1, self.__binaryTarget, partial=True) #:assert(itemId) != -1 # TODO: NOTE niekoniecznie (bo binaryTarget mogl byc rozny od pierwszego zaindeksowanego hasla) #:elem = self._item2element.get(itemId + 1) #:if elem != None and isinstance(elem, tuple) and unicode(nvl(elem[1]), "utf-8") == self.__binaryTarget: #: #print "o!", elem #: self.__selectedElement = elem #: return self.__binaryTarget #:else: #: #print "els" #: for i in self._items: #: elem = self._item2element.get(i) #: #print elem, unicode(nvl(elem[1]), "utf-8"), self.__binaryTarget #: if elem != None and isinstance(elem, tuple) and unicode(nvl(elem[1]), "utf-8") == self.__binaryTarget: #: self.__selectedElement = elem #: return self.__binaryTarget #print "ojej, stalo sie cos dziwnego" self.__binaryTarget = None self.__leftBinaryTarget = False return None
def __selectStructureNode(self, node):
log.log("StructureRegisterBrowser.__selectStructureNode", [node.getDescriptivePath()], 0)
self.__path = node.getDescriptivePath()
for l in self._listeners:
l.on_structure_element_selected(node.getDescriptivePath())
self.DeleteAllItems()
self.__fillRegister(node.getChildren())
log.log("StructureRegisterBrowser.__selectStructureNode return", [], 1)
def __onKeyUp(self, event):
log.log("WindowRegisterBrowser.__onKeyUp",
[event.GetKeyCode(), wx.WXK_PAGEUP, wx.WXK_PAGEDOWN], 0)
if event.GetKeyCode() == wx.WXK_PAGEUP:
self.__pageUp()
elif event.GetKeyCode() == wx.WXK_PAGEDOWN:
self.__pageDown()
log.log("WindowRegisterBrowser.__onKeyUp return", [], 1)
def hintChanged(self, hint):
log.log("HintRegisterBrowser.hintChanged", [hint], 0)
itemId = self._findItem(hint)
if itemId != -1:
if self._selected != None:
self._unselect(self._selected)
self._select(itemId, veto=True)
log.log("HintRegisterBrowser.hintChanged return", [], 1)
def startBinarySearch(self, target=None, restarting=False):
log.log("RegisterBrowser.startBinarySearch", [target, restarting], 0)
self._binary = True
self.__left = 0
self.__right = len(self._items) - 1
self.__markScope()
self.__selectCenter()
log.log("RegisterBrowser.startBinarySearch return", [], 1)
def reset(self):
log.log("StructreRegisterBrowser.reset", [], 0)
RegisterBrowser.reset(self)
self.__binaryAvailable = False
self.__register = None
self.__ficheLevel = False
self.__element = None
self.__path = ""
log.log("StructureRegisterBrowser.reset return", [], 1)
def setRegister(self, reg, getEntry=None):
log.log("HintRegisterBrowser.setRegister", [reg, getEntry], 0)
#self.__reverseIndex.disableSorting()
WindowRegisterBrowser.setRegister(self, reg, getEntry=getEntry)
#c = Counter()
#self.__reverseIndex.sortAll()
#print "s", c
#self.__reverseIndex.enableSorting()
log.log("HintRegisterBrowser.setRegister return", [], 1)
def binaryAcceptFinalize(self, safe=False): #from maleks.maleks.useful import Counter #gc = Counter() log.log(["binaryAcceptFinalize", self.__selectedElement, self.__binaryType]) self._selected = None #c = Counter() self.DeleteAllItems() #print "DeleteAllItems", c elements = self.__dBController.getEntriesRegisterWithGaps() #print "getEntriesRegisterWithGaps", c self.__fillRegister(elements) #print "!!!", self.__left, self.__center, self.__right #print "@@@", self.__leftFiche, self.__centerFiche, self.__rightFiche #print "fillRegister", c self.__left = None #lc = Counter() for (i, el) in self._item2element.iteritems(): #print "$$$", el, self.__centerFiche, self.__dBController.hasFiche(el, self.__centerFiche) #print el #c.reset() has = self.__dBController.hasFiche(el, self.__centerFiche) #print "hasFiche", c #print has if has:#self.__dBController.hasFiche(el, self.__centerFiche): #print "has" self.__selectedElement = el for l in self._listeners: l.on_structure_element_selected(self.__text(el)) if isinstance(el, tuple): #print "tuple" self.__binaryType = "GAP" #c.reset() (self.__left, self.__right, self.__center) = self.__dBController.getPositionsForFichesForGap(el[1], el[2], self.__leftFiche, self.__rightFiche, self.__centerFiche) #print "getPositionsForFichesForGap", c else: #print "entry" self.__binaryType = "ENTRY" #c.reset (self.__left, self.__right, self.__center) = self.__dBController.getPositionsForFichesForEntry(el, self.__leftFiche, self.__rightFiche, self.__centerFiche) #print "getPositionsForFichesForEntry", c #print self.__left, self.__center, self.__right break else: pass #print "not has" #print "loop", lc # TODO: C konczenie wyszukiwania z celem gdy wyladowalismy nie w GAP tylko w ENTRY #print ":::::", self.__centerFiche #print self.__leftFiche, self.__rightFiche, self.__left, self.__right, self.__center assert(self.__left != None) #c.reset() for l in self._listeners: l.invisible_binary_search(self.__centerFiche) if safe and self.__left == self.__right: for l in self._listeners: l.stop_binary_search()
def _select(self, itemId, veto=False):
#mapsafe
#print itemId, self._window, self.__len
log.log("WindowRegisterBrowser._select",
[itemId, veto, self._window, self._smart], 0)
if self._smart and (itemId < self._window
or itemId >= self.LIMIT() + self._window):
#print "tu"
self._scrollBrowser(itemId)
#print "ok"
RegisterBrowser._select(self, itemId, veto=veto)
log.log("WindowRegisterBrowser._select return", [], 1)
def find(self, text):
log.log("WindowRegisterBrowser.find", [text], 0)
if not self._smart:
RegisterBrowser.find(self, text)
else:
itemId = self._findItem(text)
#assert(itemId != -1)
if itemId != -1:
if self._selected != None:
self._unselect(self._selected)
self._select(itemId)
log.log("WindowRegisterBrowser.find return", [], 1)
def initialize(self):
log.log("EntryRegisterBrowser.initialize", [], 0)
if self.binarySearchActive():
for l in self._listeners:
l.stop_binary_search()
self.reset()
elements = self.__dBController.getEntriesRegister()
#print elements
#elements = ["a", "b", "c", "d"]
self.__fillRegister(elements)
self._initialized = True
log.log("EntryRegisterBrowser.initialize return", [], 1)
def setRegister(self, reg, getEntry=None):
log.log("StructureRegisterBrowser.setRegister", [reg, getEntry], 0)
if self.binarySearchActive():
for l in self._listeners:
l.stop_binary_search()
self.reset()
self.__register = reg
self.__fillRegister(reg.getRoot().getChildren())
self.__element = reg.getRoot()
self.__path = self.__element.getDescriptivePath()
self._initialized = True
log.log("StructureRegisterBrowser.setRegister return", [], 1)
def reset(self):
log.log("RegisterBrowser.reset", [], 0)
self.DeleteAllItems()
self._veto = False # patrz onSelect()
self._selected = None # identyfikator aktualnie zaznaczonego elementu
self._binary = False
self.__left = 0
self.__right = 0
self.__center = 0
self.__programmaticSelect = False # patrz onSelect()
self._initialized = False # patrz isActive()
log.log("RegisterBrowser.reset return", [], 1)
def gotoPrevFiche(self):
log.log("RegisterBrowser.gotoPrevFiche", [], 0)
if self._binary:
for l in self._listeners:
l.stop_binary_search()
if self._selected != None:
itemId = self.GetPrevItem(self._selected)
if itemId != -1:
self._unselect(self._selected)
self._select(itemId, veto=True)
self._element_selected(self._elementOf(itemId), notify=False)
log.log("RegisterBrowser.gotoPrevFiche return", [], 1)
def __fillRegister(self, elements):
log.log("EntryRegisterBrowser.initialize", [elements], 0)
i = 0
for element in elements:
self.InsertStringItem(i, element)
self.SetStringItem(i, 1, "")
self.SetStringItem(i, 2, "")
self._items.append(i)
self._item2element.setdefault(i, element)
self._element2item.setdefault(element, i)
i += 1
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
log.log("EntryRegisterBrowser.initialize return", [], 1)
def setEntry(self, entry, browsingHistory=False, unselect=False):
log.log("setEntry", [entry, browsingHistory], 0)
if browsingHistory:
self.__browsingHistory = True
self.__editPanel.SetValue(entry)
self.editPanelChanged(None)
if browsingHistory:
self.__browsingHistory = False
if unselect:
def __pom():
self.__editPanel.SetSelection(len(self.__editPanel.GetValue()), len(self.__editPanel.GetValue()))
wx.CallAfter(__pom)
log.log("setEntry return", [self.__editPanel.GetValue()], 1)
def find(self, text):
log.log("RegisterBrowser.find", [text], 0)
if self._binary: # jezeli binarne to przerywamy je
#self.stopBinarySearch()
for l in self._listeners:
l.stop_binary_search()
itemId = self.FindItem(-1, text, partial=True)
#itemId = self.findItem(2, text)
if itemId != -1:
if self._selected != None:
self._unselect(self._selected)
self._select(itemId)
log.log("RegisterBrowser.find return", [], 1)
def incrementalAdd(self, hint):
log.log("HintRegisterBrowser.incrementalAdd", [hint], 0)
#c = Counter()
if not self._initialized:
log.log("HintRegisterBrowser.incrementalAdd return", [], 2)
return
if not self._smart:
self.reinitialize()
ind = self.__binaryFind(hint)
RegisterBrowser._select(self, ind, veto=True)
log.log("HintRegisterBrowser.incrementalAdd return", [], 3)
return
ind = self.__binaryFind(hint)
if ind == len(self.__hints):
#self._items.append(len(self._items))
self._elements.append(stru(hint))
self._elementLabels.append(ustr(hint))
else:
#self._items.insert(ind, ind)
self._elements.insert(ind, stru(hint))
self._elementLabels.insert(ind, ustr(hint))
self._itemsNo += 1
#print c
self._reloadSelect(ind, veto=True)
log.log("HintRegisterBrowser.incrementalAdd return", [], 1)
def select(self, elementId):
#mapsafe
log.log("RegisterBrowser.select", [elementId], 0)
if self._binary: # jesli binarne aktywne - przerwij
#self.stopBinarySearch()
for l in self._listeners:
l.stop_binary_search()
if self._selected != None:
self._unselect(self._selected)
itemId = self._itemOf(elementId)
#print "select", itemId, elementId
if itemId != None:
self._select(itemId, veto=True) # veto=True bo ta metoda jest wywolywana
# z okna glownego wiec nie ma potrzeby powiadamiac go o zaznaczeniu
# elementu (bo to ono go zaznacza wiec wie o tym)
log.log("RegisterBrowser.select return", [], 1)
def __fillRegister(self, elements):
log.log("StructureRegisterBrowser.__fillRegister", [elements], 0)
i = 0
self._itemsNo = 0
for element in elements:
if isinstance(element, Fiche):
self.__ficheLevel = True
self.InsertStringItem(i, element.getLabel())
self.SetStringItem(i, 1, "")
self.SetStringItem(i, 2, "")
self._items.append(i)
self._item2element.setdefault(i, element.getId())
self._element2item.setdefault(element.getId(), i)
self._itemsNo += 1
i += 1
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
log.log("StructureRegisterBrowser.__fillRegister return", [], 1)
