#
# pso.gui.py - Python Service Objects
#
# Author: Thanos Vassilakis thanos@0x01.com
#
# Copyright (c) thanos vassilakis 2000,2001, 2002
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public License
# as published by the Free Software Foundation; either version 2.1 of the
# License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU Lesser General Public License for more details.
#
# See terms of license at gnu.org.
#
# $Id: gui.py,v 1.2 2003/11/18 19:04:22 thanos Exp $
#
#
# created: 21/08/2002 Thanos Vassilakis
#
#
#
from pso.util import mkDict
# application imports
from util.cache import EvalCache
class Bouncer:
def render(self, parser, attr, cdata):
if self.shouldBounce(parser, attr):
return self.bounce(parser, attr, cdata)
return ''
def shouldBounce(self, parser, attr):
return 0
def bounce(self, parser, attr, cdata):
return ''
class Link:
def render(self, parser, attr, cdata):
if self.isEnabled(parser, attr):
return self.renderEnabled(parser, attr, cdata)
else:
return self.renderDisabled(parser, attr, cdata)
def isEnabled(self, parser, attr):
return 1
def renderEnabled(self, parser, attr, cdata):
return parser.handler.url.href(cdata, **attr)
def renderDisabled(self, parser, attr, cdata):
return '<font color="gray">%s</font>' % cdata
class Info:
def render(self, parser, attr, cdata):
if self.isEnabled(parser, attr):
return self.renderInfo(parser, attr, cdata)
return ''
def isEnabled(self, parser, attr):
return 1
def renderInfo(self, parser, attr, cdata):
return cdata
class List:
def __init__(self):
self.records=None
def shouldShow(self, parser, attr) : return 1
def getRecords(self, parser, attr): pass
def processRecord(self, parser, attr, record, fields): pass
def prepare(self, parser, attr): return {}
def render(self, parser, attr, cdata):
if not self.shouldShow(parser, attr): return ''
if self.records is None:
self.records = self.sort(parser, attr)
rowlen = len(self.records)
fields = self.prepare(parser, attr)
rows = map(self.processRow, self.records, rowlen*((parser,attr, cdata, fields),))
del self.records[:]
self.records = None
return '\n'.join(rows)
def sort(self, parser, attr):
return self.getRecords(parser, attr)
def processRow (self, record, params):
parser, attr, cdata, fields = params
#MING DEBUG 01-02-03
return cdata % self.processRecord(parser, attr, record, fields)
#return str(self.processRecord(parser, attr, record, fields))
def tableMethods(celf):
table = celf()
return table.render
tableMethods = classmethod(tableMethods)
class Table(List):
PAGESZ='10'
paged=0
PAGER_HTML = """<table border="0" cellpadding="2" cellspacing="0" width="100%%"> <tr bgcolor="#FFFEF"> <td align='left' nowrap><strong><font color="gray" face="Helvetica,Helvetica"> %(legend)s %(prev)s %(next)s </font></strong></td><td align='right' nowrap> <strong></tr></table>"""
def processPager(self, parser, attr, cdata):
if self.records is None:
self.records = self.sort(parser, attr)
(legend, prev, next, self.records) = self.tabulate(parser, attr, self.records)
return mkDict(legend=legend, prev=prev, next=next)
def pager(self, parser, attr, cdata):
if not self.shouldShow(parser, attr): return ''
if not cdata:
html = self.PAGER_HTML
return html % self.processPager( parser, attr, cdata)
def uri(self, parser, attr, label, **vars):
tablename = attr.get('name','')
url = parser.handler.url.copy()
sort = vars.get('sort')
if sort is None:
sort = parser.handler.getInput(tablename+'sort')
if sort is not None:
url[tablename+'sort'] = sort
line = vars.get('line')
if not line:
line = parser.handler.getInput(tablename+'line')
if line:
url[tablename+'line'] = line
del url['delta']
return '<a href="%s">%s</a>' % (url, label)
def tabulate(self, parser, attr, records):
numberlines = len(self.records)
tablename = attr.get('name','')
line = int(parser.handler.getInput(tablename+'line', value='1'))
pagesz = int(parser.handler.getInput(tablename+'pageSize', value=self.PAGESZ))
if line > numberlines:
line=int(numberlines / pagesz)*pagesz + 1
elif (line < 1):
line=1
numberpages = numberlines/ pagesz + (numberlines % pagesz > 0)
currentpage = line/ pagesz + (line % pagesz > 0)
if (line > (1+(currentpage-1)*pagesz)):
prevpage = 1+(currentpage-1)*pagesz
nextpage=prevpage+pagesz
else:
prevpage = line - pagesz
nextpage=line + pagesz
if prevpage < 0:
prevpage = 0
if nextpage > numberlines:
nextpage = 0
records = records[int(line-1): int(line+pagesz-1)]
if nextpage:
nexturi = self.uri(parser, attr, 'next', line= nextpage)
else:
nexturi = 'next'
if prevpage:
prevuri = self.uri(parser, attr, 'prev', line= prevpage) + ' |'
else:
prevuri = 'prev |'
if not numberpages:
return 'no data', '','', []
return ('%d of %d - ' % ( currentpage, numberpages)), prevuri, nexturi, records
def tableMethods(celf):
table = celf()
return table.pager, table.render
tableMethods = classmethod(tableMethods)
class SortedTable(Table):
def sort(self, parser, attr):
records = self.getRecords(parser, attr)
records.sort()
return records
class SortableTable(Table):
SORTFIELD = "sort"
PAGEFIELD = "line"
def __init__(self):
List.__init__(self)
def toggle(self, parser, attr, current, field):
if abs(current)== field:
return -current
return field
def columnHead(self, parser, attr, currentColumn, innerhtml, default, column):
label, field = column
field +=1
field = self.toggle(parser, attr, currentColumn, field)
return self.buildTitle(parser, attr, field, innerhtml %label)
def buildTitle(self, parser, attr, field, label):
return self.uri(parser, attr, label, sort=field)
def getColumns(self, attr):
columns = attr.get("columns")
if columns:
columns = EvalCache.eval(columns, self.GLOBALS)
return columns
def sortRow(self, parser, attr, html):
if not self.shouldShow(parser, attr): return ''
tablename = attr.get('name','')
columns = self.getColumns(attr)
if columns:
innerHtml = attr.get("innehtml", "%s")
default = EvalCache.eval(attr.get("default","1"), self.GLOBALS)
currentField = parser.handler.getInput(tablename+'sort')
if not currentField:
currentField = default
else:
currentField = int(currentField)
sortrow = [ self.columnHead(parser, attr, currentField, innerHtml, default, column) for column in columns]
return html % tuple(sortrow)
return html
def sort(self, parser, attr):
tablename = attr.get('name','')
records = self.getRecords(parser, attr)
column = parser.handler.getInput(tablename+'sort')
if not column:
column = self.getDefaultSort(parser.handler, attr)
else:
column = int(column)
if column:
records = sortTab(records, column)
return records
def getDefaultSort(self, handler, attr):
value = EvalCache.eval(attr.get("default","0"), self.GLOBALS)
if value > 0:
value +=1
elif value < 0:
value -=1
return value
def tableMethods(celf):
table = celf()
return table.pager, table.sortRow, table.render
tableMethods = classmethod(tableMethods)
class Tab:
def __init__(self, action, label):
self.action, self.label = action, label
def render(self, parser, attr, cdata=''):
if self.isEnabled(parser):
return self.renderEnabled(parser, attr, cdata)
else:
return self.renderDisabled(parser, attr, cdata)
def renderEnabled(self, parser, attr, cdata):
return parser.handler.url.href(self.getLabel(parser), action=self.action)
def renderDisabled(self, parser, attr, cdata):
return self.getLabel(parser)
def getLabel(self, parser):
return self.label
def isEnabled(self, parser):
return parser.handler.getInput('action') != self.action
class TabBar:
SPACER= ' | '
HTML="%s"
def render(self, parser, attr, cdata=''):
if not cdata:
cdata = self.HTML
try:
bar = self.getBar(parser, attr)
spacer = attr.setdefault('spacer', self.SPACER)
if bar:
tabs = [tab.render(parser, attr, cdata) for tab in self.TABS.get(bar, ())]
return cdata % spacer.join(tabs)
return ''
except Exception,e:
print "<!--"
import sys
import traceback
traceback.print_exc(file=sys.stdout)
return str(e)
print "-->"
def getBar(self, parser, attr): pass
|