class EventLinkPopup(PopupPanel):
def __init__(self, editor):
PopupPanel.__init__(self, glass=True)
self.m_origAnchorStart = None
self.m_origAnchorEnd = None
self.m_origTargetText = ""
self.m_editor = editor
vpanel = VerticalPanel()
vpanel.setWidth("350px")
self.m_webPageText = TextBox()
self.m_webPageText.setText("http:#")
self.m_webPageText.setWidth("320px")
vpanel.add(self.m_webPageText)
lbl = Label("Display:")
self.m_targetText = TextBox()
self.m_targetText.setWidth("100%")
lpanel = HorizontalPanel()
lpanel.add(lbl)
lpanel.add(self.m_targetText)
vpanel.add(lpanel)
self.m_fillOutCB = CheckBox("Change entire link")
self.m_fillOutCB.setVisible(False)
self.m_fillOutCB.addClickListener(self)
vpanel.add(self.m_fillOutCB)
self.m_okBut = Button("Ok", self)
self.m_okBut.addStyleName("float-left")
self.m_cancelBut = Button("Cancel", self)
self.m_cancelBut.addStyleName("float-left")
hpanel = HorizontalPanel()
hpanel.add(self.m_okBut)
hpanel.add(self.m_cancelBut)
vpanel.add(hpanel)
self.add(vpanel)
self.setStyleName("gwt-DialogBox")
def refresh(self):
try:
self.m_editor.getSelection()
self.m_range = self.m_editor.getRange()
if self.m_range is None:
return False
else:
self.m_selTexts = self.m_range.getSelectedTextElements()
if self.m_selTexts is None:
return False
else:
self.m_origTargetText = self.m_range.getText()
self.m_targetText.setText(self.m_origTargetText)
anchor = self.getAnchor(self.m_selTexts)
if anchor is not None:
href = anchor.getHref().strip()
if href:
self.m_webPageText.setText(href)
self.m_origAnchorStart = self.getAnchorLimit(
self.m_range.getStartPoint().getTextNode(),
anchor, False)
self.m_origAnchorEnd = self.getAnchorLimit(
self.m_range.getStartPoint().getTextNode(),
anchor, True)
if self.m_range.getStartPoint().equals(self.m_origAnchorStart) and self.m_range.getStartPoint().equals(self.m_origAnchorEnd):
self.m_origAnchorStart = None
self.m_origAnchorEnd = None
else:
self.m_fillOutCB.setVisible(True)
self.m_fillOutCB.setValue(True)
self.m_origTargetText = self.fetchStringFromTexts(
self.m_origAnchorStart, self.m_origAnchorEnd)
self.m_targetText.setText(self.m_origTargetText)
except:
print "exception"
traceback.print_exc()
return False
return True
def _apply(self):
formatter = self.m_editor.getFormatter()
link = self.m_webPageText.getText().strip()
if not link:
return False
print self.m_origAnchorStart, self.m_origAnchorEnd
if (self.m_origAnchorStart is not None) and self.m_fillOutCB.getValue():
# Expand selection to these bounds
self.m_range.setRange(self.m_origAnchorStart, self.m_origAnchorEnd)
# Ensure the selection hasn't changed, or at least changes to the
# expanded bounds we want
Selection.setRange(self.m_range)
targetText = self.m_targetText.getText()
if self.m_range.isCursor():
# Insert into a single cursor location
newEle = DOM.createAnchor()
newEle.href = link
newEle.innerText = targetText
sp = self.m_range.getStartPoint()
startNode = sp.getTextNode()
offset = sp.getOffset()
print "sp", sp, startNode, offset
parentEle = startNode.parentElement
text = startNode.data
if offset == 0:
parentEle.insertBefore(newEle, startNode)
else:
if offset < len(text):
# Split this in two and insert the node between
startNode.splitText(offset)
DOM.insertAfter(startNode, newEle)
Selection.setRange(Range(newEle))
elif targetText != self.m_origTargetText:
# Replace whatever was selected with this text
ele = self.m_range.surroundContents()
newEle = DOM.createAnchor()
newEle.href = link
newEle.innerText = targetText
ele.parentElement.replaceChild(newEle, ele)
Selection.setRange(Range(newEle))
else:
formatter.createLink(link)
return True
def getAnchor(self, node):
res = None
if isinstance(node, list):
nodes = node
for node in nodes:
res = self.getAnchor(node)
if res is not None:
break
return res
ele = node.parentElement
while ele is not None:
tag = ele.tagName
if tag.lower == "a":
res = ele
break
ele = ele.parentElement
return res
def getAnchorLimit(self, node, anchor, forward):
href = anchor.href
while True:
prevNode = node
node = Range.getAdjacentTextElement(prevNode, forward)
if node is not None:
cmpAnchor = self.getAnchor(node)
if (cmpAnchor is None) or not href == cmpAnchor.href:
break
if node is None:
break
res = RangeEndPoint()
res.setTextNode(prevNode)
res.setOffset(forward and prevNode.getData().length() or 0)
return res
def parseEventLink(self, href):
res = 0
idx = href.index("#event=")
if idx > 0:
try:
res = href[idx+7:]
except:
pass
return res
def createEventLink(self, id):
return "#event=" + id
def fetchStringFromTexts(self, startPoint, endPoint):
res = None
texts = Range.getSelectedTextElements(
startPoint.getTextNode(), endPoint.getTextNode())
if texts is not None:
res = self.fetchStringFromTexts(texts, startPoint, endPoint)
return res
def fetchStringFromTexts(self, allTexts, startPoint, endPoint):
selText = ""
for node in allTexts:
val = node.getData()
if node == startPoint.getTextNode():
if node == endPoint.getTextNode():
val = val.substring[startPoint.getOffset():
endPoint.getOffset()]
else:
val = val[startPoint.getOffset():]
elif node == endPoint.getTextNode():
val = val[:endPoint.getOffset()]
selText += val
return selText
def onClick(self, sender):
if sender == self.m_cancelBut:
self.hide()
elif sender == self.m_okBut:
if self._apply():
self.hide()
elif sender == self.m_fillOutCB:
if self.m_fillOutCB.getValue():
self.m_origTargetText = fetchStringFromTexts(self.m_origAnchorStart,
self.m_origAnchorEnd)
self.m_targetText.setValue(self.m_origTargetText)
else:
self.m_origTargetText = self.m_range.getText()
self.m_targetText.setValue(self.m_origTargetText)
def checkSuggestValid(self):
self.m_okBut.setEnabled(True)
def execute(self):
self.checkSuggestValid()
def deferredCheckValid(self):
DeferredCommand.addCommand(self)
class LatBuilderWeb:
def setStyleSheet(self, sheet):
e = DOM.createElement('link')
e.setAttribute('rel', 'stylesheet')
e.setAttribute('type', 'text/css')
e.setAttribute('href', sheet)
html = Window.getDocumentRoot().parentElement
head = html.getElementsByTagName('head').item(0)
head.appendChild(e)
def includeMathJax(self, config):
html = Window.getDocumentRoot().parentElement
head = html.getElementsByTagName('head').item(0)
e = DOM.createElement('script')
e.setAttribute('type', 'text/javascript')
e.setAttribute(
'src', 'http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=' +
config)
head.appendChild(e)
e = DOM.createElement('script')
e.setAttribute('type', 'text/javascript')
e.textContent = 'function Typeset() { MathJax.Hub.Queue(["Typeset",MathJax.Hub]); }'
head.appendChild(e)
def onModuleLoad(self):
self.current_request = None
Window.setTitle("Lattice Builder Web Interface")
self.setStyleSheet("./LatBuilderWeb.css")
self.includeMathJax('TeX-AMS-MML_HTMLorMML')
self.TEXT_WAITING = "Lattice Builder is working..."
self.TEXT_ERROR = "Server Error"
self.FIGURES_OF_MERIT = [
# (key, name)
('{cs}P2', 'P2'),
('{cs}P4', 'P4'),
('{cs}P6', 'P6'),
('{cs}R{alpha}', 'R_alpha'),
('spectral', 'spectral'),
]
self.CONSTRUCTION_METHODS = [
('explicit:{genvec}', "Explicit (Evaluation)",
"Evaluates the figure of merit for a given generating vector.<br/>"
"<strong>Please specify the generating vector in the Lattice "
"Properties panel above.</strong>"),
('exhaustive', "Exhaustive",
"Examines all generating vectors and retains the best one."),
('random:{samples}', "Random",
"Examines a number of randomly selected generating vectors and "
"retains the best one."),
('Korobov', "Korobov",
"Examines all generating vectors of the form (1, a, a^2 mod n, "
"..., a^s mod n) and retains the best one."),
('random-Korobov:{samples}', "Random Korobov",
"Examines a number of randomly selected generating vectors of "
"the form (1, a, a^2 mod n, ..., a^s mod n) and retains the "
"best one."),
('CBC', "Component-by-Component",
"Examines all possible values of the components of the "
"generating vector and selects the best ones, one coordinate "
"at a time."),
('random-CBC:{samples}', "Random Component-by-Component",
"Examines a number of randomly selected values of the "
"components of the generating vector and selects the best "
"ones, one coordinate at a time."),
('fast-CBC', "Fast Component-by-Component",
"Examines all possible values of the components of the "
"generating vector and selects the best ones, one coordinate "
"at a time. Computation is accelerated by using fast "
"Fourier transforms."),
]
self.COMBINER_TYPES = [
('level:max', 'highest level'),
('sum', 'weighted sum'),
('max', 'maximum weighted value'),
]
self.NORMALIZATION_TYPES = [
('norm:P{alpha}-SL10', 'SL10 P-alpha'),
('norm:P{alpha}-DPW08', 'DPW08 P-alpha'),
]
captionstyle = {
'Width': '10em',
'HorizontalAlignment': 'right',
}
self.remote = LatBuilderService()
WeightValuesArray.REMOTE = self.remote
main_panel = VerticalPanel(Spacing=30)
# information
info = """<h2>Lattice Builder Web Interface</h2>
<p>This Web interface allows
<a href="https://github.com/mungerd/latbuilder#readme">Lattice Builder</a>
users to call the executable program without having to construct the
command line explicitly.
</p>
<p>Enter the construction parameters below, and press the <em>Search for
Good Lattices</em> button. The results will show at the bottom.
</p>"""
main_panel.add(HTML(info))
self.version_label = HTML()
main_panel.add(self.version_label)
self.remote.backend_version(self)
params_panel = VerticalPanel(Spacing=15)
main_panel.add(params_panel)
# lattice type and size and dimension
lat_panel = VerticalPanel()
params_panel.add(CaptionPanel("Lattice Properties", lat_panel))
lat_panel.add(
HTML(
r'\[ P_n = \left\{ (i \boldsymbol a \bmod n) / n \::\: i = 0, \dots, n \right\} \qquad (\boldsymbol a \in \mathbb Z^s) \]',
StyleName='DisplayMath'))
self.size = TextBox(Text="2^10")
self.size.addChangeListener(self)
self.embedded = CheckBox("embedded")
self.embedded.addClickListener(self)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML(r"Size (\(n\)): ", StyleName="CaptionLabel"))
panel.add(self.size)
panel.add(self.embedded)
lat_panel.add(panel)
self.dimension = TextBox(Text="3")
self.dimension.addChangeListener(self)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML(r"Dimension (\(s\)): ", StyleName="CaptionLabel"))
panel.add(self.dimension)
lat_panel.add(panel)
self.generating_vector = GeneratingVector(self.size)
self.generating_vector.panel.setVisible(False)
lat_panel.add(self.generating_vector.panel)
# figure of merit
merit_panel = VerticalPanel()
params_panel.add(CaptionPanel("Figure of Merit", merit_panel))
merit_panel.add(
HTML(
r"\[ \left[ \mathcal D_q(P_n) \right]^q = "
r"\sum_{\emptyset \neq u \subseteq \{1,\dots,s\}}"
r"\gamma_u^q \, \left[\mathcal D_u(P_n)\right]^q"
r"\qquad (q > 0) \]",
StyleName='DisplayMath'))
self.norm_type = TextBox(Text="2")
self.norm_type.addChangeListener(self)
panel = HorizontalPanel(Spacing=8)
panel.add(
HTML(r"Norm type (\(q\) or <b>inf</b>): ",
StyleName="CaptionLabel"))
panel.add(self.norm_type)
merit_panel.add(panel)
self.merit = ListBox()
self.merit.addChangeListener(self)
for key, name in self.FIGURES_OF_MERIT:
self.merit.addItem(name)
self.merit_cs = CheckBox("Use coordinate-symmetric implementation",
Checked=True)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Figure of merit: ", StyleName="CaptionLabel"))
panel.add(self.merit)
panel.add(self.merit_cs)
merit_panel.add(panel)
self.merit_alpha_panel = HorizontalPanel(Spacing=8)
self.merit_alpha = TextBox(Text="2")
self.merit_alpha_panel.add(
HTML("Value of alpha: ", StyleName="CaptionLabel"))
self.merit_alpha_panel.add(self.merit_alpha)
merit_panel.add(self.merit_alpha_panel)
# filters and combiner
multilevel_panel = VerticalPanel(Spacing=8)
self.multilevel_panel = CaptionPanel("Multilevel Filters and Combiner",
multilevel_panel,
Visible=False)
params_panel.add(self.multilevel_panel)
self.ml_normalization_enable = CheckBox("Normalization")
self.ml_normalization_enable.addClickListener(self)
multilevel_panel.add(self.ml_normalization_enable)
self.ml_normalization_panel = VerticalPanel(Spacing=4,
Visible=False,
StyleName='SubPanel')
multilevel_panel.add(self.ml_normalization_panel)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Normalization type: ", StyleName="CaptionLabel"))
self.ml_normalization_type = ListBox()
for key, name in self.NORMALIZATION_TYPES:
self.ml_normalization_type.addItem(name, value=key)
panel.add(self.ml_normalization_type)
self.ml_normalization_panel.add(panel)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Minimum level: ", StyleName="CaptionLabel"))
self.ml_min_level = TextBox(Text="1")
panel.add(self.ml_min_level)
self.ml_normalization_panel.add(panel)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Maximum level: ", StyleName="CaptionLabel"))
self.ml_max_level = TextBox(Text="1")
panel.add(self.ml_max_level)
self.ml_normalization_panel.add(panel)
self.ml_lowpass_enable = CheckBox("Low-pass filter")
self.ml_lowpass_enable.addClickListener(self)
multilevel_panel.add(self.ml_lowpass_enable)
self.ml_lowpass_panel = VerticalPanel(Spacing=4,
Visible=False,
StyleName='SubPanel')
multilevel_panel.add(self.ml_lowpass_panel)
self.ml_lowpass = TextBox(Text="1.0")
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Low-pass threshold: ", StyleName="CaptionLabel"))
panel.add(self.ml_lowpass)
self.ml_lowpass_panel.add(panel)
self.combiner_type = ListBox()
for key, name in self.COMBINER_TYPES:
self.combiner_type.addItem(name, value=key)
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Combiner: ", StyleName="CaptionLabel"))
panel.add(self.combiner_type)
multilevel_panel.add(panel)
# weights
self.weights = CompoundWeights()
weights_panel = VerticalPanel()
params_panel.add(CaptionPanel("Weights", weights_panel))
weights_panel.add(
HTML(r"\[ \gamma_u^p \qquad (u \subseteq \{1, \dots, s\}) \]",
StyleName='DisplayMath'))
self.weights_power = TextBox(Text="2")
panel = HorizontalPanel(Spacing=8)
panel.add(HTML(r"Weights power (\(p\)): ", StyleName="CaptionLabel"))
panel.add(self.weights_power)
weights_panel.add(panel)
weights_panel.add(self.weights.panel)
self.weights.add_weights(ProductWeights)
# construction method
cons_panel = VerticalPanel()
params_panel.add(CaptionPanel("Construction Method", cons_panel))
self.construction = ListBox()
self.construction.addChangeListener(self)
for key, name, desc in self.CONSTRUCTION_METHODS:
self.construction.addItem(name, value=key)
self.construction_desc = HTML()
panel = HorizontalPanel(Spacing=8)
panel.add(self.construction)
panel.add(self.construction_desc)
cons_panel.add(panel)
self.construction_samples_panel = HorizontalPanel(Spacing=8)
self.construction_samples = TextBox(Text="30")
self.construction_samples_panel.add(
HTML("Random samples: ", StyleName="CaptionLabel"))
self.construction_samples_panel.add(self.construction_samples)
cons_panel.add(self.construction_samples_panel)
# execute button
panel = VerticalPanel(Spacing=8,
Width="100%",
HorizontalAlignment='center')
main_panel.add(panel)
button_panel = HorizontalPanel()
panel.add(button_panel)
self.button_search = Button("Search", self)
button_panel.add(self.button_search)
self.button_abort = Button("Abort", self, Visible=False)
button_panel.add(self.button_abort)
self.status = Label()
panel.add(self.status)
# results
results_panel = VerticalPanel()
self.results_panel = CaptionPanel("Results",
results_panel,
Visible=False)
main_panel.add(self.results_panel)
self.results_size = Label()
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Lattice size: ", StyleName="ResultsCaptionLabel"))
panel.add(self.results_size)
results_panel.add(panel)
self.results_gen = Label()
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Generating vector: ", StyleName="ResultsCaptionLabel"))
panel.add(self.results_gen)
results_panel.add(panel)
self.results_merit = Label()
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("Merit value: ", StyleName="ResultsCaptionLabel"))
panel.add(self.results_merit)
results_panel.add(panel)
self.results_cpu_time = Label()
panel = HorizontalPanel(Spacing=8)
panel.add(HTML("CPU time: ", StyleName="ResultsCaptionLabel"))
panel.add(self.results_cpu_time)
results_panel.add(panel)
self.results_cmd = Label(StyleName='Command', Visible=False)
panel = HorizontalPanel(Spacing=8)
self.results_cmd_link = Hyperlink("Command line: ",
StyleName="ResultsCaptionLabel")
self.results_cmd_link.addClickListener(self)
panel.add(self.results_cmd_link)
panel.add(self.results_cmd)
results_panel.add(panel)
# update selections
self.construction.selectValue('CBC')
self.onChange(self.size)
self.onChange(self.construction)
self.onChange(self.merit)
self.onChange(self.dimension)
self.onClick(self.embedded)
self.onChange(self.ml_normalization_enable)
self.onChange(self.ml_lowpass_enable)
RootPanel().add(main_panel)
def onChange(self, sender):
if sender == self.construction:
key, name, desc = \
self.CONSTRUCTION_METHODS[self.construction.getSelectedIndex()]
self.construction_desc.setHTML(desc)
self.construction_samples_panel.setVisible('{samples}' in key)
if key.startswith('explicit'):
self.generating_vector.panel.setVisible(True)
self.button_search.setText("Evaluate Figure of Merit")
else:
self.generating_vector.panel.setVisible(False)
self.button_search.setText("Search for Good Lattices")
elif sender == self.merit:
key, name = \
self.FIGURES_OF_MERIT[self.merit.getSelectedIndex()]
self.merit_alpha_panel.setVisible('{alpha}' in key)
self.merit_cs.setVisible('{cs}' in key)
elif sender == self.size:
max_level = LatSize(self.size.getText()).max_level
if int(self.ml_min_level.getText()) > max_level:
self.ml_min_level.setText(max_level)
self.ml_max_level.setText(max_level)
elif sender == self.dimension:
# resize weights
dimension = int(self.dimension.getText())
self.generating_vector.dimension = dimension
self.weights.dimension = dimension
elif sender == self.norm_type:
q = self.norm_type.getText().strip()
self.merit_cs.setVisible(q == '2')
if q == 'inf':
self.weights_power.setText('1')
else:
self.weights_power.setText(q)
def onClick(self, sender):
if sender == self.embedded:
self.multilevel_panel.setVisible(self.embedded.getChecked())
elif sender == self.ml_normalization_enable:
self.ml_normalization_panel.setVisible(
self.ml_normalization_enable.getChecked())
elif sender == self.ml_lowpass_enable:
self.ml_lowpass_panel.setVisible(
self.ml_lowpass_enable.getChecked())
elif sender == self.results_cmd_link:
self.results_cmd.setVisible(not self.results_cmd.getVisible())
elif sender == self.button_search:
self.results_panel.setVisible(False)
self.button_search.setVisible(False)
self.button_abort.setVisible(True)
lattype = self.embedded.getChecked() and 'embedded' or 'ordinary'
size = self.size.getText()
dimension = self.dimension.getText()
norm_type = self.norm_type.getText()
merit, merit_name = \
self.FIGURES_OF_MERIT[self.merit.getSelectedIndex()]
alpha = self.merit_alpha.getText()
cs = norm_type == 2 and self.merit_cs.getChecked() and 'CS:' or ''
weights_power = self.weights_power.getText()
weights = [w.as_arg() for w in self.weights.weights]
construction, construction_name, desc = \
self.CONSTRUCTION_METHODS[self.construction.getSelectedIndex()]
samples = self.construction_samples.getText()
genvec = ','.join(self.generating_vector.values)
mlfilters = []
combiner_type = None
if self.embedded.getChecked():
if self.ml_normalization_enable.getChecked():
ml_normalization_type, ml_normalization_name = \
self.NORMALIZATION_TYPES[self.ml_normalization_type.getSelectedIndex()]
ml_normalization_type += ':even:{},{}'.format(
self.ml_min_level.getText(),
self.ml_max_level.getText())
mlfilters.append(ml_normalization_type.format(alpha=alpha))
if self.ml_lowpass_enable.getChecked():
mlfilters.append('low-pass:{}'.format(
self.ml_lowpass.getText()))
combiner_type, combiner_name = \
self.COMBINER_TYPES[self.combiner_type.getSelectedIndex()]
self.status.setText(self.TEXT_WAITING)
self.current_request = self.remote.latbuilder_exec(
lattype, size, dimension, norm_type,
merit.format(alpha=alpha, cs=cs),
construction.format(samples=samples, genvec=genvec), weights,
weights_power, None, mlfilters, combiner_type, self)
elif sender == self.button_abort:
# Need to patch JSONService.sendRequest():
#
# return HTTPRequest().asyncPost(self.url, msg_data,
# JSONResponseTextHandler(request_info)
# False, self.content_type,
# self.headers)
if self.current_request:
self.current_request.abort()
self.current_request = None
self.button_abort.setVisible(False)
self.button_search.setVisible(True)
elif sender == self.product_weights_expr_link:
self.showDialog(self._product_weights_expr_dialog)
elif sender == self.order_weights_expr_link:
self.showDialog(self._order_weights_expr_dialog)
def onRemoteResponse(self, response, request_info):
try:
if request_info.method == 'latbuilder_exec':
self.button_search.setVisible(True)
self.button_abort.setVisible(False)
cmd, points, gen, merit, seconds = eval(response)
self.results_size.setText(points)
self.results_gen.setText(', '.join(gen))
self.results_merit.setText(merit)
self.results_cpu_time.setText(format_time(seconds=seconds))
self.results_cmd.setText(cmd)
self.results_panel.setVisible(True)
self.status.setText("")
elif request_info.method == 'backend_version':
version = response
self.version_label.setHTML(
"<b>Backend:</b> {}".format(version))
except:
self.status.setText(response.replace('\n', ' | '))
def onRemoteError(self, code, errobj, request_info):
if request_info.method == 'latbuilder_exec':
self.button_search.setVisible(True)
self.button_abort.setVisible(False)
message = errobj['message']
if code != 0:
self.status.setText("HTTP error %d: %s" % (code, message['name']))
else:
code = errobj['code']
if code == -32603:
self.status.setText("Aborted.")
else:
self.status.setText("JSONRPC Error %s: %s" % (code, message))
class EventLinkPopup(PopupPanel):
def __init__(self, editor):
PopupPanel.__init__(self, glass=True)
self.m_origAnchorStart = None
self.m_origAnchorEnd = None
self.m_origTargetText = ""
self.m_editor = editor
vpanel = VerticalPanel()
vpanel.setWidth("350px")
self.m_webPageText = TextBox()
self.m_webPageText.setText("http:#")
self.m_webPageText.setWidth("320px")
vpanel.add(self.m_webPageText)
lbl = Label("Display:")
self.m_targetText = TextBox()
self.m_targetText.setWidth("100%")
lpanel = HorizontalPanel()
lpanel.add(lbl)
lpanel.add(self.m_targetText)
vpanel.add(lpanel)
self.m_fillOutCB = CheckBox("Change entire link")
self.m_fillOutCB.setVisible(False)
self.m_fillOutCB.addClickListener(self)
vpanel.add(self.m_fillOutCB)
self.m_okBut = Button("Ok", self)
self.m_okBut.addStyleName("float-left")
self.m_cancelBut = Button("Cancel", self)
self.m_cancelBut.addStyleName("float-left")
hpanel = HorizontalPanel()
hpanel.add(self.m_okBut)
hpanel.add(self.m_cancelBut)
vpanel.add(hpanel)
self.add(vpanel)
self.setStyleName("gwt-DialogBox")
def refresh(self):
try:
self.m_editor.getSelection()
self.m_range = self.m_editor.getRange()
if self.m_range is None:
return False
else:
self.m_selTexts = self.m_range.getSelectedTextElements()
if self.m_selTexts is None:
return False
else:
self.m_origTargetText = self.m_range.getText()
self.m_targetText.setText(self.m_origTargetText)
anchor = self.getAnchor(self.m_selTexts)
if anchor is not None:
href = anchor.getHref().strip()
if href:
self.m_webPageText.setText(href)
self.m_origAnchorStart = self.getAnchorLimit(
self.m_range.getStartPoint().getTextNode(),
anchor, False)
self.m_origAnchorEnd = self.getAnchorLimit(
self.m_range.getStartPoint().getTextNode(),
anchor, True)
if self.m_range.getStartPoint().equals(self.m_origAnchorStart) and self.m_range.getStartPoint().equals(self.m_origAnchorEnd):
self.m_origAnchorStart = None
self.m_origAnchorEnd = None
else:
self.m_fillOutCB.setVisible(True)
self.m_fillOutCB.setValue(True)
self.m_origTargetText = self.fetchStringFromTexts(
self.m_origAnchorStart, self.m_origAnchorEnd)
self.m_targetText.setText(self.m_origTargetText)
except:
print "exception"
traceback.print_exc()
return False
return True
def _apply(self):
formatter = self.m_editor.getFormatter()
link = self.m_webPageText.getText().strip()
if not link:
return False
print self.m_origAnchorStart, self.m_origAnchorEnd
if (self.m_origAnchorStart is not None) and self.m_fillOutCB.getValue():
# Expand selection to these bounds
self.m_range.setRange(self.m_origAnchorStart, self.m_origAnchorEnd)
# Ensure the selection hasn't changed, or at least changes to the
# expanded bounds we want
Selection.setRange(self.m_range)
targetText = self.m_targetText.getText()
if self.m_range.isCursor():
# Insert into a single cursor location
newEle = DOM.createAnchor()
newEle.setHref(link)
newEle.setInnerText(targetText)
sp = self.m_range.getStartPoint()
startNode = sp.getTextNode()
offset = sp.getOffset()
print "sp", sp, startNode, offset
parentEle = startNode.parentElement
text = startNode.data
if offset == 0:
parentEle.insertBefore(newEle, startNode)
else:
if offset < text.length():
# Split this in two and insert the node between
startNode.splitText(offset)
parentEle.insertAfter(newEle, startNode)
Selection.setRange(Range(newEle))
elif targetText != self.m_origTargetText:
# Replace whatever was selected with this text
ele = self.m_range.surroundContents()
newEle = DOM.createAnchor()
newEle.href = link
newEle.innerText = targetText
ele.parentElement.replaceChild(newEle, ele)
Selection.setRange(Range(newEle))
else:
formatter.createLink(link)
return True
def getAnchor(self, node):
res = None
if isinstance(node, list):
nodes = node
for node in nodes:
res = self.getAnchor(node)
if res is not None:
break
return res
ele = node.parentElement
while ele is not None:
tag = ele.tagName
if tag.lower == "a":
res = ele
break
ele = ele.parentElement
return res
def getAnchorLimit(self, node, anchor, forward):
href = anchor.href
while True:
prevNode = node
node = Range.getAdjacentTextElement(prevNode, forward)
if node is not None:
cmpAnchor = self.getAnchor(node)
if (cmpAnchor is None) or not href == cmpAnchor.href:
break
if node is None:
break
res = RangeEndPoint()
res.setTextNode(prevNode)
res.setOffset(forward and prevNode.getData().length() or 0)
return res
def parseEventLink(self, href):
res = 0
idx = href.index("#event=")
if idx > 0:
try:
res = href[idx+7:]
except:
pass
return res
def createEventLink(self, id):
return "#event=" + id
def fetchStringFromTexts(self, startPoint, endPoint):
res = None
texts = Range.getSelectedTextElements(
startPoint.getTextNode(), endPoint.getTextNode())
if texts is not None:
res = self.fetchStringFromTexts(texts, startPoint, endPoint)
return res
def fetchStringFromTexts(self, allTexts, startPoint, endPoint):
selText = ""
for node in allTexts:
val = node.getData()
if node == startPoint.getTextNode():
if node == endPoint.getTextNode():
val = val.substring[startPoint.getOffset():
endPoint.getOffset()]
else:
val = val[startPoint.getOffset():]
elif node == endPoint.getTextNode():
val = val[:endPoint.getOffset()]
selText += val
return selText
def onClick(self, sender):
if sender == self.m_cancelBut:
self.hide()
elif sender == self.m_okBut:
if self._apply():
self.hide()
elif sender == self.m_fillOutCB:
if self.m_fillOutCB.getValue():
self.m_origTargetText = fetchStringFromTexts(self.m_origAnchorStart,
self.m_origAnchorEnd)
self.m_targetText.setValue(self.m_origTargetText)
else:
self.m_origTargetText = self.m_range.getText()
self.m_targetText.setValue(self.m_origTargetText)
def checkSuggestValid(self):
self.m_okBut.setEnabled(True)
def execute(self):
self.checkSuggestValid()
def deferredCheckValid(self):
DeferredCommand.addCommand(self)