← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/widget/browser.py

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mfrom: (0.9.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080622211713-fpo2zrq3s5dfecxg
Tags: 1.7.0-3
Simplify /etc/moin/wikilist format: "USER URL" (drop unneeded middle
CONFIG_DIR that was wrongly advertised as DATA_DIR).  Make
moin-mass-migrate handle both formats and warn about deprecation of
the old one.

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/widget/browser.py
2
2
"""
3
3
    MoinMoin - DataBrowserWidget
4
4
 
5
 
    @copyright: 2002 by J�rgen Hermann <jh@web.de>
 
5
    @copyright: 2002 Juergen Hermann <jh@web.de>
6
6
    @license: GNU GPL, see COPYING for details.
7
7
"""
8
8
 
9
9
from MoinMoin.widget import base
10
 
 
 
10
from MoinMoin import wikiutil
11
11
 
12
12
class DataBrowserWidget(base.Widget):
13
13
 
14
 
    def __init__(self, request, **kw):
 
14
    def __init__(self, request, show_header=True, **kw):
 
15
        _ = request.getText
15
16
        base.Widget.__init__(self, request, **kw)
16
17
        self.data = None
 
18
        self.data_id = 'dbw.'
 
19
        # prefixed with __ are untranslated and to be used in the JS
 
20
        self._all = _('[all]')
 
21
        self.__all = '[all]'
 
22
        self._notempty = _('[not empty]')
 
23
        self.__notempty = '[notempty]'
 
24
        self._empty = _('[empty]')
 
25
        self.__empty = '[empty]'
 
26
        self._filter = _('filter')
 
27
        self.__filter = 'filter'
 
28
        self._show_header = show_header
17
29
 
18
30
    def setData(self, dataset):
19
31
        """ Sets the data for the browser (see MoinMoin.util.dataset).
20
32
 
21
 
        @param dataset: dataset containg either ascii or unicode
 
33
        @param dataset: dataset containing either ascii, unicode or tuples.
 
34
                        If a dataset entry contains a tuple then the first
 
35
                        item in the tuple is displayed and the second item
 
36
                        is used for autofilters.
22
37
        """
23
38
        self.data = dataset
24
 
 
25
 
    def toHTML(self):
 
39
        if dataset.data_id:
 
40
            self.data_id = 'dbw.%s.' % dataset.data_id
 
41
 
 
42
    def _name(self, elem):
 
43
        """ return name tag for a HTML element
 
44
        @param elem: element name, will be prefixed by data id
 
45
        """
 
46
        return 'name="%s%s"' % (self.data_id, elem)
 
47
 
 
48
    def _makeoption(self, item, selected, ntitem=None):
 
49
        """ create an option for a <select> form element
 
50
        @param item: string containing the item name to show
 
51
        @param selected: indicates whether the item should be default or not
 
52
        """
 
53
        if selected:
 
54
            selected = ' selected'
 
55
        else:
 
56
            selected = ''
 
57
        assert(isinstance(item, basestring))
 
58
        if ntitem is None:
 
59
            ntitem = item
 
60
        return '<option value="%s"%s>%s</option>' % (
 
61
            wikiutil.escape(ntitem, True),
 
62
            selected,
 
63
            wikiutil.escape(item))
 
64
 
 
65
    def _filteroptions(self, idx):
 
66
        """ create options for all elements in the column
 
67
            given by idx
 
68
        """
 
69
        self.data.reset()
 
70
        row = self.data.next()
 
71
        # [empty] is a special already
 
72
        unique = ['']
 
73
 
 
74
        value = None
 
75
        name = '%sfilter%d' % (self.data_id, idx)
 
76
        if name in self.request.form:
 
77
            value = self.request.form[name][0]
 
78
        while row:
 
79
            option = row[idx]
 
80
            if isinstance(option, tuple):
 
81
                option = option[1]
 
82
            if not option in unique:
 
83
                unique.append(option)
 
84
            row = self.data.next()
 
85
 
 
86
        # fill in the empty field we left blank
 
87
        del unique[0]
 
88
        unique.sort()
 
89
        result = [self._makeoption(item, item == value) for item in unique]
 
90
        common = [None, None, None]
 
91
        common[0] = self._makeoption(self._all, value == self.__all, self.__all)
 
92
        common[1] = self._makeoption(self._empty, value == self.__empty, self.__empty)
 
93
        common[2] = self._makeoption(self._notempty, value == self.__notempty, self.__notempty)
 
94
        return '\n'.join(common + result)
 
95
 
 
96
    def format(self):
26
97
        fmt = self.request.formatter
27
98
 
28
99
        result = []
29
 
        result.append(fmt.table(1))
 
100
        result.append(fmt.rawHTML('<form action="%s/%s" method="GET" name="%sform">' % (self.request.getScriptname(), wikiutil.quoteWikinameURL(self.request.page.page_name), self.data_id)))
 
101
        result.append(fmt.div(1))
 
102
 
 
103
        havefilters = False
 
104
        for col in self.data.columns:
 
105
            if col.autofilter:
 
106
                havefilters = True
 
107
                break
 
108
        if havefilters:
 
109
            result.append(fmt.rawHTML('<input type="submit" value="%s" %s>' % (self._filter, self._name('submit'))))
 
110
 
 
111
        result.append(fmt.table(1, id='%stable' % self.data_id))
30
112
 
31
113
        # add header line
32
 
        result.append(fmt.table_row(1))
33
 
        for col in self.data.columns:
34
 
            if col.hidden: continue
35
 
            result.append(fmt.table_cell(1))
36
 
            result.append(fmt.strong(1))
37
 
            result.append(col.label or col.name)
38
 
            result.append(fmt.strong(0))
39
 
            result.append(fmt.table_cell(0))
40
 
        result.append(fmt.table_row(0))
41
 
 
42
 
        # add data
43
 
        self.data.reset()
44
 
        row = self.data.next()
45
 
        while row:
 
114
        if self._show_header:
46
115
            result.append(fmt.table_row(1))
47
 
            for idx in range(len(row)):
48
 
                if self.data.columns[idx].hidden: continue
 
116
            for idx in range(len(self.data.columns)):
 
117
                col = self.data.columns[idx]
 
118
                if col.hidden:
 
119
                    continue
49
120
                result.append(fmt.table_cell(1))
50
 
                result.append(unicode(row[idx]))
 
121
                result.append(fmt.strong(1))
 
122
                result.append(col.label or col.name)
 
123
                result.append(fmt.strong(0))
 
124
 
 
125
                if col.autofilter:
 
126
                    result.append(fmt.linebreak(False))
 
127
                    select = '<select %s onchange="dbw_update_search(\'%s\');">%s</select>' % (
 
128
                                      self._name('filter%d' % idx),
 
129
                                      self.data_id,
 
130
                                      self._filteroptions(idx))
 
131
                    result.append(fmt.rawHTML(select))
 
132
 
51
133
                result.append(fmt.table_cell(0))
52
134
            result.append(fmt.table_row(0))
 
135
 
 
136
        # add data
 
137
        self.data.reset()
 
138
        row = self.data.next()
 
139
        if row is not None:
 
140
            filters = [None] * len(row)
 
141
 
 
142
            if havefilters:
 
143
                for idx in range(len(row)):
 
144
                    name = '%sfilter%d' % (self.data_id, idx)
 
145
                    if name in self.request.form:
 
146
                        filters[idx] = self.request.form[name][0]
 
147
                        if filters[idx] == self._all:
 
148
                            filters[idx] = None
 
149
 
 
150
        while row:
 
151
            hidden = False
 
152
 
 
153
            if havefilters:
 
154
                # check if row needs to be hidden due to filtering
 
155
                for idx in range(len(row)):
 
156
                    if filters[idx]:
 
157
                        if isinstance(row[idx], tuple):
 
158
                            data = unicode(row[idx][1])
 
159
                        else:
 
160
                            data = unicode(row[idx])
 
161
                        if data != '' and filters[idx] == self._notempty:
 
162
                            continue
 
163
                        if data == '' and filters[idx] == self._empty:
 
164
                            continue
 
165
                        if data != filters[idx]:
 
166
                            hidden = True
 
167
                            break
 
168
 
 
169
            if not hidden:
 
170
                result.append(fmt.table_row(1))
 
171
                for idx in range(len(row)):
 
172
                    if self.data.columns[idx].hidden:
 
173
                        continue
 
174
                    if isinstance(row[idx], tuple):
 
175
                        result.append(fmt.table_cell(1, abbr=unicode(row[idx][1])))
 
176
                        result.append(unicode(row[idx][0]))
 
177
                    else:
 
178
                        result.append(fmt.table_cell(1))
 
179
                        result.append(unicode(row[idx]))
 
180
                    result.append(fmt.table_cell(0))
 
181
                result.append(fmt.table_row(0))
 
182
 
53
183
            row = self.data.next()
54
184
 
55
185
        result.append(fmt.table(0))
 
186
        result.append(fmt.div(0))
 
187
        result.append(fmt.rawHTML('</form>'))
56
188
        return ''.join(result)
57
189
 
 
190
    toHTML = format # old name of "format" function DEPRECATED, will be removed in 1.7
58
191
 
59
192
    def render(self):
60
 
        self.request.write(self.toHTML())
 
193
        self.request.write(self.format())
61
194