543 lines
16 KiB
Python
543 lines
16 KiB
Python
import sys
|
|
import curses
|
|
import dbLayer as db
|
|
from form import bookForm,categoryForm
|
|
|
|
class browserWindow:
|
|
hl=0
|
|
topline = 0
|
|
entries = []
|
|
selected = list()
|
|
commands = [(' /', 'search'), (' n', 'find next'), (' N', 'find previous'), (' q', 'quit')]
|
|
cs = []
|
|
# column definitions are in (label, weight, specified width) triples
|
|
columnDefs = [('something',1,None)]
|
|
mx = my = 0
|
|
cx = cy = 0
|
|
# for searches
|
|
last_search = ""
|
|
found_index = 0
|
|
|
|
def __init__(self,window,helpbar):
|
|
self.w = window
|
|
self.hb = helpbar
|
|
self.updateGeometry()
|
|
self.commands = self.cs+self.commands
|
|
|
|
def sortByColumn(self, col):
|
|
self.entries.sort(key=lambda k: k.get(col)) # key=dict.get(col))
|
|
self.selected = list(map(lambda x: False, self.selected))
|
|
|
|
def updateGeometry(self):
|
|
(self.my,self.mx)=self.w.getmaxyx()
|
|
(y,x) = self.w.getbegyx()
|
|
self.cx = x + self.mx//2
|
|
self.cy = y + self.my//2
|
|
self.pageSize = self.my-4
|
|
self.calcColWidths()
|
|
|
|
def calcColWidths(self):
|
|
total_weights = 0
|
|
available_space = self.mx - len(self.columnDefs) -2
|
|
cols = []
|
|
for label,weight,value in self.columnDefs:
|
|
if value!=None:
|
|
available_space -= value
|
|
else:
|
|
total_weights+=weight
|
|
|
|
for label,weight,value in self.columnDefs:
|
|
if value!=None:
|
|
cols.append((label,value))
|
|
else:
|
|
cols.append((label,available_space*weight//total_weights))
|
|
self.columns=cols
|
|
|
|
def refresh(self):
|
|
self.hb.commands = self.commands
|
|
self.hb.refresh()
|
|
self.w.box()
|
|
self.displayHeader()
|
|
for r in range(0,self.pageSize):
|
|
self.displayRow(r)
|
|
self.w.refresh()
|
|
self.highlight()
|
|
|
|
def clear(self):
|
|
self.w.erase()
|
|
self.w.refresh()
|
|
|
|
def centreChild(self,child):
|
|
(y,x)=child.getmaxyx()
|
|
child.mvwin(self.cy-y//2,self.cx-x//2)
|
|
|
|
|
|
def displayHeader(self):
|
|
cursor = 2
|
|
for header,width in self.columns:
|
|
self.w.addnstr(1,cursor,header+" "*width,width)
|
|
self.w.addstr(2,cursor,"-"*width)
|
|
cursor += width+1
|
|
|
|
def displayRow(self,row):
|
|
if self.topline+row < len(self.entries):
|
|
entry = self.entries[self.topline+row]
|
|
cursor = 2
|
|
self.w.addnstr(row+3, 1, " "*self.mx,self.mx-2)
|
|
if self.selected[self.topline+row]:
|
|
self.w.addstr(row+3, 1, "*")
|
|
else:
|
|
self.w.addstr(row+3, 1, " ")
|
|
for k,width in self.columns:
|
|
if k.lower() in entry:
|
|
self.w.addnstr(row+3,cursor,str(entry[k.lower()])+" "*width,width)
|
|
cursor += width+1
|
|
else:
|
|
self.w.addstr(row+3,1," "*(self.mx-2))
|
|
|
|
def highlight(self):
|
|
row = self.hl-self.topline+3
|
|
if row > 1 and row < self.my:
|
|
self.w.chgat(row,1,self.mx-2,curses.A_REVERSE)
|
|
|
|
def unHighlight(self):
|
|
row = self.hl-self.topline+3
|
|
if row > 1 and row < self.my:
|
|
self.w.chgat(row,1,self.mx-2,curses.A_NORMAL)
|
|
|
|
def mvHighlight(self,delta):
|
|
new = self.hl+delta
|
|
new = max(new,0)
|
|
new = min(new,len(self.entries)-1)
|
|
self.unHighlight()
|
|
self.hl = new
|
|
self.highlight()
|
|
|
|
def scroll(self,delta):
|
|
self.unHighlight()
|
|
self.topline += delta
|
|
self.topline = min(self.topline,len(self.entries)-1)
|
|
self.topline = max(self.topline,0)
|
|
self.refresh()
|
|
|
|
def search(self, string):
|
|
i = 0
|
|
found = False
|
|
for e in self.entries:
|
|
for k,v in e.items():
|
|
if str(v).find(string) != -1:
|
|
found = True
|
|
if found:
|
|
break
|
|
i += 1;
|
|
if found:
|
|
self.last_search = string
|
|
self.search_index = i
|
|
return i
|
|
else:
|
|
self.search_index = -1
|
|
return -1
|
|
|
|
def findNext(self):
|
|
if self.last_search == "" or self.search_index == -1:
|
|
return -1
|
|
found = False
|
|
for i in range(self.hl+1,len(self.entries)-1):
|
|
for k,v in self.entries[i].items():
|
|
if str(v).find(self.last_search) != -1:
|
|
found = True
|
|
if found:
|
|
break
|
|
if found:
|
|
self.search_index = i
|
|
return i
|
|
else:
|
|
return -1
|
|
|
|
def findPrevious(self):
|
|
if self.last_search == "" or self.search_index == -1:
|
|
return -1
|
|
found = False
|
|
for i in range(self.hl-1, 0, -1):
|
|
for k,v in self.entries[i].items():
|
|
if str(v).find(self.last_search) != -1:
|
|
found = True
|
|
if found:
|
|
break
|
|
if found:
|
|
self.search_index = i
|
|
return i
|
|
else:
|
|
return -1
|
|
|
|
|
|
def eventLoop(self):
|
|
self.w.keypad(1)
|
|
self.refresh()
|
|
|
|
ch = self.w.getch()
|
|
while ch != 27 and ch != 113:
|
|
ch = self.handleInput(ch)
|
|
if ch==113:
|
|
return {}
|
|
self.w.refresh()
|
|
ch = self.w.getch()
|
|
self.hb.refresh()
|
|
|
|
def handleInput(self,ch):
|
|
if ch == curses.KEY_UP or ch == 107 or ch == 16:
|
|
if self.hl == self.topline:
|
|
self.scroll(-self.pageSize//2-1)
|
|
self.mvHighlight(-1)
|
|
elif ch == curses.KEY_DOWN or ch == 106 or ch == 14:
|
|
if self.hl == self.topline+self.pageSize-1:
|
|
self.scroll(+self.pageSize//2+1)
|
|
self.mvHighlight(+1)
|
|
elif ch == curses.KEY_PPAGE:
|
|
self.scroll(-self.pageSize)
|
|
self.mvHighlight(-self.pageSize)
|
|
elif ch == curses.KEY_NPAGE:
|
|
self.scroll(+self.pageSize)
|
|
self.mvHighlight(+self.pageSize)
|
|
elif ch == 47: # forward slash
|
|
string = self.hb.getSearch()
|
|
hl = self.search(string)
|
|
if hl != -1:
|
|
delta = hl - self.hl
|
|
self.scroll(delta)
|
|
self.mvHighlight(delta)
|
|
else:
|
|
self.hb.display(string+' not found')
|
|
elif ch == 110: # n
|
|
hl = self.findNext()
|
|
if hl != -1:
|
|
delta = hl - self.hl
|
|
self.scroll(delta)
|
|
self.mvHighlight(delta)
|
|
else:
|
|
self.hb.display(self.last_search+' not found')
|
|
elif ch == 78: # N
|
|
hl = self.findPrevious()
|
|
if hl != -1:
|
|
delta = hl - self.hl
|
|
self.scroll(delta)
|
|
self.mvHighlight(delta)
|
|
else:
|
|
self.hb.display(self.last_search+' not found')
|
|
elif ch == 270: # F6 Sorts
|
|
w = curses.newwin(40,20,20,20)
|
|
cl = columnSelector(w,self.hb)
|
|
self.centreChild(w)
|
|
col = cl.eventLoop()
|
|
cl.clear()
|
|
self.sortByColumn(col)
|
|
self.clear()
|
|
self.refresh()
|
|
elif ch == 32:
|
|
if len(self.selected)>0:
|
|
self.selected[self.hl] = not self.selected[self.hl]
|
|
self.displayRow(self.hl-self.topline)
|
|
self.highlight()
|
|
|
|
|
|
|
|
class trashBrowser(browserWindow):
|
|
columnDefs = [('ID',0,3),
|
|
('ISBN',0,13),
|
|
('Authors',30,None),
|
|
('Title',60,None)]
|
|
|
|
cs = [(' r', 'restore selected'), (' d', 'delete selected')]
|
|
|
|
# redefinable functions
|
|
def viewSelection(self,book):
|
|
bookid = book['id']
|
|
w=curses.newwin(1,1,20,20)
|
|
bf = bookForm(w,self.hb,book)
|
|
self.centreChild(w)
|
|
bf.caption='Viewing Book '+str(bookid)
|
|
bf.blabel='done'
|
|
bf.eventLoop()
|
|
bf.clear()
|
|
|
|
def restoreSelected(self):
|
|
books = []
|
|
for sel,book in zip(self.selected, self.entries):
|
|
if sel:
|
|
books.append(book)
|
|
db.restoreBooks(books)
|
|
|
|
def delSelected(self):
|
|
books = []
|
|
for sel,book in zip(self.selected, self.entries):
|
|
if sel:
|
|
books.append(book)
|
|
db.deleteBooks(books)
|
|
|
|
def refreshBooks(self):
|
|
self.entries = db.getRemovedBooks()
|
|
self.selected = list(map(lambda x:False, self.entries))
|
|
|
|
def handleInput(self,ch):
|
|
browserWindow.handleInput(self,ch)
|
|
if ch == 10:
|
|
book = self.entries[self.hl]
|
|
self.viewSelection(book)
|
|
self.refresh()
|
|
if ch==114: #restore books
|
|
count=0
|
|
for s in self.selected[0:self.hl-1]:
|
|
if s:
|
|
count+=1
|
|
self.restoreSelected()
|
|
self.refreshBooks()
|
|
self.refresh()
|
|
self.scroll(-count)
|
|
self.mvHighlight(-count)
|
|
if ch==100: # delete books
|
|
count=0
|
|
for s in self.selected[0:self.hl-1]:
|
|
if s:
|
|
count+=1
|
|
self.delSelected()
|
|
self.refreshBooks()
|
|
self.refresh()
|
|
self.scroll(-count)
|
|
self.mvHighlight(-count)
|
|
return ch
|
|
|
|
class bookBrowser(browserWindow):
|
|
columnDefs = [('ID',0,3),
|
|
('ISBN',0,13),
|
|
('Authors',30,None),
|
|
('Title',60,None)]
|
|
|
|
cs = [(' u', 'update'), (' d', 'delete selected')]
|
|
|
|
# redefinable functions
|
|
def updateSelection(self,book):
|
|
bookid = book['id']
|
|
|
|
w=curses.newwin(1,1)
|
|
bf=bookForm(w,self.hb,book)
|
|
self.centreChild(w)
|
|
bf.caption='Update Book '+str(bookid)
|
|
bf.blabel='update'
|
|
newbook = bf.eventLoop()
|
|
if len(newbook)!=0:
|
|
db.updateBook(newbook,bookid)
|
|
bf.clear()
|
|
|
|
def viewSelection(self,book):
|
|
bookid = book['id']
|
|
w=curses.newwin(1,1,20,20)
|
|
bf = bookForm(w,self.hb,book)
|
|
self.centreChild(w)
|
|
bf.caption='Viewing Book '+str(bookid)
|
|
bf.blabel='done'
|
|
bf.eventLoop()
|
|
bf.clear()
|
|
|
|
def categorizeSelection(self,book):
|
|
w = curses.newwin(40,20,20,20)
|
|
cs = categorySelector(w,self.hb)
|
|
self.centreChild(w)
|
|
cs.book = book
|
|
cs.refreshCategories()
|
|
cs.eventLoop()
|
|
cs.clear()
|
|
|
|
def delSelected(self):
|
|
books = []
|
|
for sel,book in zip(self.selected, self.entries):
|
|
if sel:
|
|
books.append(book)
|
|
db.removeBooks(books)
|
|
|
|
def refreshBooks(self):
|
|
self.entries = db.getBooks()
|
|
self.selected = list(map(lambda x:False, self.entries))
|
|
|
|
def refreshBooksInCategory(self,cat):
|
|
self.entries = db.getBooksByCategory(cat)
|
|
self.selected = list(map(lambda x:False, self.entries))
|
|
|
|
def handleInput(self,ch):
|
|
browserWindow.handleInput(self,ch)
|
|
if ch == 117: #update on 'u'
|
|
book = self.entries[self.hl]
|
|
self.updateSelection(book)
|
|
self.entries[self.hl]=db.getBookByID(book['id'])
|
|
self.refresh()
|
|
elif ch == 10:
|
|
book = self.entries[self.hl]
|
|
self.viewSelection(book)
|
|
self.refresh()
|
|
elif ch == 99:
|
|
book = self.entries[self.hl]
|
|
self.categorizeSelection(book)
|
|
self.refresh()
|
|
if ch==100:
|
|
count=0
|
|
for s in self.selected[0:self.hl-1]:
|
|
if s:
|
|
count+=1
|
|
self.delSelected()
|
|
self.refreshBooks()
|
|
self.refresh()
|
|
self.scroll(-count)
|
|
self.mvHighlight(-count)
|
|
return ch
|
|
|
|
class categoryBrowser(browserWindow):
|
|
columnDefs = [('Category',100,None)]
|
|
cs = [(' a', 'add category'), (' d', 'delete selected')]
|
|
|
|
|
|
def refreshCategories(self):
|
|
self.entries = db.getCategories()
|
|
self.sortByColumn('category')
|
|
self.selected = list(map(lambda x:False, self.entries))
|
|
|
|
def addCategory(self):
|
|
w = curses.newwin(1,1,10,10)
|
|
cf = categoryForm(w,self.hb)
|
|
self.centreChild(w)
|
|
cats = cf.eventLoop()
|
|
for c in cats:
|
|
db.addCategory(c)
|
|
cf.clear()
|
|
|
|
def viewCategory(self):
|
|
w = curses.newwin(20,80,20,20)
|
|
b = bookBrowser(w,self.hb)
|
|
self.centreChild(w)
|
|
b.refreshBooksInCategory(self.entries[self.hl])
|
|
b.eventLoop()
|
|
b.clear()
|
|
|
|
def delSelected(self):
|
|
categories = []
|
|
for sel,cat in zip(self.selected, self.entries):
|
|
if sel:
|
|
categories.append(cat)
|
|
db.deleteCategories(categories)
|
|
|
|
def handleInput(self,ch):
|
|
browserWindow.handleInput(self,ch)
|
|
if ch==97:
|
|
self.addCategory()
|
|
self.refreshCategories()
|
|
self.refresh()
|
|
if ch ==10:
|
|
self.viewCategory()
|
|
self.refresh()
|
|
if ch==100:
|
|
count=0
|
|
for s in self.selected[0:self.hl-1]:
|
|
if s:
|
|
count+=1
|
|
self.delSelected()
|
|
self.refreshCategories()
|
|
self.refresh()
|
|
self.scroll(-count)
|
|
self.mvHighlight(-count)
|
|
return ch
|
|
|
|
class categorySelector(browserWindow):
|
|
columnDefs = [('Category',100,None)]
|
|
cs = [(' a', 'add category'), (' c', 'commit')]
|
|
book = {'id':''}
|
|
original=[]
|
|
|
|
|
|
def refreshCategories(self):
|
|
self.entries = db.getCategories()
|
|
self.sortByColumn('category')
|
|
self.refreshSelected()
|
|
|
|
def refreshSelected(self):
|
|
self.original = list(map(lambda x:False, self.entries))
|
|
cats = db.getBookCategories(self.book)
|
|
cats.sort()
|
|
cats.sort(key=lambda k: k.get('category')) # key=dict.get(col))
|
|
i = 0
|
|
j = 0
|
|
for cat in self.entries:
|
|
if i == len(cats):
|
|
break
|
|
if cat['id']==cats[i]['cat_id']:
|
|
self.original[j] = True;
|
|
i+=1
|
|
j+=1
|
|
self.selected = self.original[:]
|
|
|
|
|
|
def addCategory(self):
|
|
w = curses.newwin(1,1,10,10)
|
|
cf = categoryForm(w,self.hb)
|
|
self.centreChild(w)
|
|
cats = cf.eventLoop()
|
|
for c in cats:
|
|
db.addCategory(c)
|
|
cf.clear()
|
|
|
|
def updateCategories(self):
|
|
# first removed the deselected ones
|
|
uncats = []
|
|
cats = []
|
|
for old, new, category in zip(self.original, self.selected, self.entries):
|
|
if old and (not new):
|
|
uncats.append(category)
|
|
if (not old) and new:
|
|
cats.append(category)
|
|
db.uncategorizeBook(self.book, uncats)
|
|
# add the newly selected categories
|
|
db.categorizeBook(self.book, cats)
|
|
|
|
|
|
def handleInput(self,ch):
|
|
browserWindow.handleInput(self,ch)
|
|
if ch==97:
|
|
self.addCategory()
|
|
self.refreshCategories()
|
|
self.refresh()
|
|
if ch==99:
|
|
self.updateCategories()
|
|
return 113
|
|
|
|
|
|
|
|
class columnSelector(browserWindow):
|
|
columnDefs = [('Column',100,None)]
|
|
entries = [{'column': 'id'}, {'column': 'isbn'}, {'column': 'lccn'},
|
|
{'column': 'title'}, {'column': 'subtitle'}, {'column': 'authors'},
|
|
{'column': 'edition'}, {'column': 'publisher'},
|
|
{'column': 'publish year'}, {'column': 'publish month'},
|
|
{'column': 'publish location'}, {'column': 'pages'}, {'column': 'pagination'},
|
|
{'column': 'weight'}, {'column': 'last updated'}]
|
|
|
|
def __init__(self,window,helpbar):
|
|
self.selected = [False,False,False,False,False,False,False,
|
|
False,False,False,False,False,False,False,False]
|
|
browserWindow.__init__(self,window,helpbar)
|
|
|
|
|
|
def eventLoop(self):
|
|
self.w.keypad(1)
|
|
self.refresh()
|
|
|
|
ch = self.w.getch()
|
|
while ch != 27 and ch != 113:
|
|
ch = self.handleInput(ch)
|
|
if ch==10:
|
|
col = self.entries[self.hl]
|
|
return col['column']
|
|
self.w.refresh()
|
|
ch = self.w.getch()
|
|
self.hb.refresh()
|
|
|
|
def handleInput(self,ch):
|
|
browserWindow.handleInput(self,ch)
|
|
return ch
|