def research_entry_changed_cb(self, widget):
"""Callback executed when the user types some
data in the research entry"""
if self.vocabularyController.getCurrentProject() is None:
return
text = widget.get_text()
tformat = self._view.research_format.get_active_text()
if text == "":
self.decolorizeAllResult()
return
# Stop current search process (and wit for it stops)
self.stopSearch()
while self.searchRunning:
time.sleep(0.001)
# Disallow nav in search results while none are computed
self._view.research_previous.set_sensitive(False)
self._view.research_next.set_sensitive(False)
self._view.currentSelectedResultLabel.set_label("")
if len(text) > 0:
Job(self.startNewSearch(text, tformat))
def sequence_execute_clicked_cb(self, widget):
"""Callback executed when the user request to start
the alignment process"""
self._view.sequence_cancel.set_sensitive(False)
self._view.sequence_execute.set_sensitive(False)
self._view.sequence_scale.set_sensitive(False)
self._view.sequence_spinbutton.set_sensitive(False)
self._view.radiobutton4bit.set_sensitive(False)
self._view.radiobutton8bit.set_sensitive(False)
self._view.orphanButton.set_sensitive(False)
self._view.smoothButton.set_sensitive(False)
# retrieves the alignment parameters
similarityPercent = self._view.sequence_adjustment.get_value()
if self._view.radiobutton8bit.get_mode():
unitSize = 8
else:
unitSize = 4
orphan = self._view.orphanButton.get_active()
smooth = self._view.smoothButton.get_active()
self.vocabularyController.getCurrentProject().getConfiguration().setVocabularyInferenceParameter(ProjectConfiguration.VOCABULARY_EQUIVALENCE_THRESHOLD, int(similarityPercent))
self.vocabularyController.getCurrentProject().getConfiguration().setVocabularyInferenceParameter(ProjectConfiguration.VOCABULARY_ORPHAN_REDUCTION, orphan)
self.vocabularyController.getCurrentProject().getConfiguration().setVocabularyInferenceParameter(ProjectConfiguration.VOCABULARY_DO_INTERNAL_SLICK, smooth)
# Configure Needleman and Wunsch
self.alignmentSolution = NeedlemanAndWunsch(unitSize, self.vocabularyController.getCurrentProject(), self.doUpgma, self.percentOfAlignmentProgessBar)
# Define the alignment JOB
self._view.sequence_stop.set_sensitive(True)
Job(self.startSequenceAlignment(unitSize))
def simple_execute_clicked_cb(self, widget):
self.flagStop = False
# update widget
self._view.simple_cancel.set_sensitive(False)
self._view.simple_execute.set_sensitive(False)
self._view.radiobutton4bits.set_sensitive(False)
self._view.radiobutton8bits.set_sensitive(False)
self._view.radiobutton16bits.set_sensitive(False)
self._view.radiobutton32bits.set_sensitive(False)
self._view.radiobutton64bits.set_sensitive(False)
self._view.simple_stop.set_sensitive(True)
#extract chosen value
formatBits = UnitSize.BITS8
if self._view.radiobutton4bits.get_active():
formatBits = UnitSize.BITS4
elif self._view.radiobutton16bits.get_active():
formatBits = UnitSize.BITS16
elif self._view.radiobutton32bits.get_active():
formatBits = UnitSize.BITS32
elif self._view.radiobutton64bits.get_active():
formatBits = UnitSize.BITS64
# create a job to execute the partitioning
Job(self.startSimplePartitioning(formatBits))
def executeButton_clicked_cb(self, event):
"""Callback executed when the user requests to start the execution"""
self._view.cancelButton.set_sensitive(True)
self.flagStop = False
# create a job to execute the partitioning
Job(self.startEnvDepsSearch())
def executeArbitrarySearch(self, searchTasks):
"""Special method to execute and displays results
obtained after searching provided tasks"""
if self.vocabularyController.getCurrentProject() is None:
return
self.show()
Job(self.startArbitrarySearch(searchTasks))
def importButton_clicked_cb(self, widget):
"""Callback executed when the user request to
import the selected messages"""
selectedMessages = self.selectedMessages
selectedCount = len(selectedMessages)
if selectedCount != 0:
currentProjectName = self.getCurrentProject().getName()
# Threaded import process
Job(self.startImportMessages(selectedMessages))
def startInference(self, button):
# We retrieve the specified value
actorType = self.targetOfInferenceCombo.get_active_text()
actorIP = self.IPEntry.get_text()
actorNetworkProtocol = self.combo_protocolOfNetworkActor.get_active_text(
)
ourPort = int(self.ourPortEntry.get_text())
targetPort = int(self.targetPortEntry.get_text())
scriptFilename = self.scriptEntry.get_text()
maxNumberOfState = int(self.MaxStatesEntry.get_text())
inputDictionary = []
for symbol in self.project.getVocabulary().getSymbols():
# if symbol.getName() == "LOGIN" or symbol.getName() == "EXECUTE" or symbol.getName() == "LOGOUT" or symbol.getName() == "DOWNLOAD":
inputDictionary.append(symbol)
inputDictionary.append(UnknownSymbol())
# Close the current dialog
self.dialog.destroy()
anID = str(uuid.uuid4())
memory = Memory()
if actorType == "CLIENT":
# Lets create a simple network oracle
oracleCommunicationChannel = NetworkServer(anID, memory,
actorNetworkProtocol,
"127.0.0.1", ourPort,
actorIP, targetPort)
else:
# Lets create a simple network oracle
oracleCommunicationChannel = NetworkClient(anID, memory,
actorNetworkProtocol,
"127.0.0.1", ourPort,
actorIP, targetPort)
# Lets create an equivalence oracle
equivalenceOracle = WMethodNetworkEquivalenceOracle(
oracleCommunicationChannel, maxNumberOfState, scriptFilename)
# Lets create the automatic inferer
self.inferer = GrammarInferer(self.project.getVocabulary(),
inputDictionary,
oracleCommunicationChannel,
equivalenceOracle, scriptFilename,
self.callback_submitedQuery,
self.callback_hypotheticalAutomaton)
# Open the new dialog which shows the status of the inferring process
self.createInferringStatusView()
# Start the progress bar
GObject.timeout_add(200, self.do_pulse)
# Start the inferer
self.job = Job(self.startInferer())
def findSizeFields_cb(self, button, dialog, sizeFieldIdentifier, symbols, cancelButton, savedEncapsulationLevel):
# first we deactivate the start button
button.set_sensitive(False)
# reactivate the cancel button
cancelButton.set_sensitive(True)
self.currentExecutionOfFindSizeFieldHasFinished = False
# Start the progress bar
GObject.timeout_add(100, self.do_pulse_for_findSizeField)
# Start the findsize field JOB
Job(self.startFindSizeField(sizeFieldIdentifier, symbols, dialog, savedEncapsulationLevel))
def smooth_execute_clicked_cb(self, widget):
"""Callback executed when the user
requests to start the smooth
operation"""
# update widget
self._view.smooth_cancel.set_sensitive(False)
self._view.smooth_execute.set_sensitive(False)
self._view.smooth_stop.set_sensitive(True)
# Define the smooth JOB
Job(self.startSmooth())
#update button
self._view.smooth_cancel.set_sensitive(True)
self._view.smooth_execute.set_sensitive(False)
self._view.smooth_stop.set_sensitive(False)
def reset_execute_clicked_cb(self, widget):
"""Callback executed when the user
requests to start the r
operation"""
# update widget
self._view.reset_cancel.set_sensitive(False)
self._view.reset_execute.set_sensitive(False)
self._view.reset_stop.set_sensitive(True)
# Define the reset JOB
Job(self.startReset())
#update button
self._view.reset_cancel.set_sensitive(True)
self._view.reset_execute.set_sensitive(False)
self._view.reset_stop.set_sensitive(False)
def force_execute_clicked_cb(self, widget):
#extract choose value
delimiter = self._view.force_entry.get_text()
if delimiter is None or delimiter == "":
return
#update widget
self.flagStop = False
self._view.force_stop.set_sensitive(True)
self._view.force_cancel.set_sensitive(False)
self._view.force_execute.set_sensitive(False)
self._view.force_entry.set_sensitive(False)
self._view.force_radiobutton_hexa.set_sensitive(False)
self._view.force_radiobutton_string.set_sensitive(False)
if self._view.force_radiobutton_hexa.get_active():
delimiterType = Format.HEX
else:
delimiterType = Format.STRING
# encode the delimiter
encodedDelimiter = TypeConvertor.encodeGivenTypeToNetzobRaw(delimiter, delimiterType)
# create a job to execute the partitioning
Job(self.startForcePartitioning(encodedDelimiter, delimiterType))
def advancedBugreportingTestkey_clicked_cb(self, button):
"""Called when the use clicks on the "Test Key" button."""
self.view.testKeyUpdateSpinnerState(state=1)
Job(self._startKeyValidation())