def getRange():
jsRange = SelectionImpl.getJSRange(m_document, m_selection)
if jsRange is None:
return None
res = Range(m_document, jsRange)
res.ensureEndPoints()
return res
def getRange():
jsRange = SelectionImpl.getJSRange(m_document, m_selection)
if jsRange is None:
return None
res = Range(m_document, jsRange)
res.ensureEndPoints()
return res
def __init__ (self, minimum, maximum, step=1.0):
Range.__init__ (self, minimum, maximum, step)
# Internal click and mouse enter detection.
self.__click = False
self._signals[SIG_MOUSEDOWN] = []
self._signals[SIG_MOUSEMOVE] = []
self._signals[SIG_MOUSEUP] = []
self._signals[SIG_KEYDOWN] = None # Dummy for keyboard activation.
def __init__(self, minimum, maximum, step=1.0):
Range.__init__(self, minimum, maximum, step)
# Internal click and mouse enter detection.
self.__click = False
self._signals[SIG_MOUSEDOWN] = []
self._signals[SIG_MOUSEMOVE] = []
self._signals[SIG_MOUSEUP] = []
self._signals[SIG_KEYDOWN] = None # Dummy for keyboard activation.
def run_simulation():
xs = Range(get_space_divisions(), get_width())
ts = Range(get_time_divisions(), get_max_time())
potential = Potential.init(xs, xs.center_function(get_selected_potential()))
psi_init = Wf.init(xs, Wf.offset(xs.center_function(get_selected_wave()), get_wave_offset()))
psi = get_algorithm()(xs, ts, potential, psi_init, get_boundary_conditions())
viz = get_selected_viz()
if viz == opt_animation:
Visualize.animate_wave(xs,ts,psi,potential)
if viz == opt_heatmap:
Visualize.heatmap(psi)
class App(QMainWindow):
def __init__(self):
super().__init__()
# specify length and width for main window
self.title = 'Network Scanner'
self.left = 10
self.top = 10
self.width = 440
self.height = 480
self.setWindowFlags(Qt.WindowCloseButtonHint)
self.initUI()
def initUI(self): # this function for GUI creation
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
###########
# main label
self.label = QLabel('Network Scanner', self)
self.label.setStyleSheet("font: 20pt;")
self.label.move(100, 50)
self.label.resize(250, 50)
####
# just label
self.labe2 = QLabel('choose the way to start scan ', self)
self.labe2.setStyleSheet("font: 13pt;")
self.labe2.move(80, 120)
self.labe2.resize(350, 50)
#####
# create button for scan specific window
self.button = QPushButton('Scan using specific IP address', self)
self.button.move(50, 200)
self.button.resize(350, 50)
self.button.setStyleSheet("font: 10pt;")
self.button.clicked.connect(self.on_click)
###############
# create button for scan range window
self.button2 = QPushButton('Scan using IP address range', self)
self.button2.move(50, 300)
self.button2.resize(350, 50)
self.button2.setStyleSheet("font: 10pt;")
self.button2.clicked.connect(self.on_click2)
self.show()
def on_click(self): # function for Specific scan window
self.S = Specific() # call Specific class
self.S.show() # show the window for Specific scan
########
@pyqtSlot()
def on_click2(self): # function for Range scan window
self.R = Range() # call Range class
self.R.show() # show the window for Range scan
def compute(energy, width, height): space_divisions = 300 length = 30 time_divisions = 300 time = 2 xs = Range(space_divisions, length) ts = Range(time_divisions, time) barrier_size = int((length/space_divisions)*width) potential = Pt.init(xs, xs.center_function(Pt.barrier(width,height))) psi_init = Wf.init(xs, Wf.offset(xs.center_function(Wf.traveling_wave(energy)), -5)) psi = FiniteDifference.solve2(xs, ts, potential, psi_init, False) integrate(psi[200,:], xs, barrier_size) Visualize.heatmap(psi)
def __init__ (self):
Range.__init__ (self, 0, 1, 1)
# Signals.
self._signals[SIG_MOUSEDOWN] = []
self._signals[SIG_MOUSEMOVE] = []
self._signals[SIG_MOUSEUP] = []
self._signals[SIG_KEYDOWN] = None # Dummy for keyboard activation.
self._signals[SIG_TICK] = None # Dummy for automatic scrolling.
# Internal state handlers for the events. Those need to be known by
# the inheritors.
self._button_dec = False
self._button_inc = False
self._click = False
def run_simulation():
xs = Range(get_space_divisions(), get_width())
ts = Range(get_time_divisions(), get_max_time())
potential = Potential.init(
xs, xs.center_function(get_selected_potential()))
psi_init = Wf.init(
xs,
Wf.offset(xs.center_function(get_selected_wave()),
get_wave_offset()))
psi = get_algorithm()(xs, ts, potential, psi_init,
get_boundary_conditions())
viz = get_selected_viz()
if viz == opt_animation:
Visualize.animate_wave(xs, ts, psi, potential)
if viz == opt_heatmap:
Visualize.heatmap(psi)
def __init__(self):
Range.__init__(self, 0, 1, 1)
# Signals.
self._signals[SIG_MOUSEDOWN] = []
self._signals[SIG_MOUSEMOVE] = []
self._signals[SIG_MOUSEUP] = []
self._signals[SIG_KEYDOWN] = None # Dummy for keyboard activation.
self._signals[SIG_TICK] = None # Dummy for automatic scrolling.
# Internal state handlers for the events. Those need to be known by
# the inheritors.
self._buttondec = False
self._buttoninc = False
self._timer = _TIMER
self._click = False
def __init__(self):
self.iattack = Range(0.001, 0.05)
self.idur = Range(0.1, .5)
self.ipan = Range(0, 1, False)
self.ifreq1 = Range(20, 8000)
self.ifreq2 = Range(20, 8000)
self.ihness = Range(0, .1, False)
self.idist = Range(0.25, 1)
def __init__(self):
wavelengthRange = Range(min=Length(nanometers=180),
max=Length(nanometers=1130))
sellmeierCoefficientPairs = ((5.684027565e-1, 5.101829712e-3),
(1.726177391e-1, 1.821153936e-2),
(2.086189578e-2, 2.620722293e-2),
(1.130748688e-1, 1.069792721e1))
RefractiveIndexSellmeier.__init__(
self,
wavelengthRange=wavelengthRange,
sellmeierCoefficientPairs=sellmeierCoefficientPairs)
return
def test_combine_true(self):
rObj = Range(5, 12)
combined_obj = self.rngObj.combine(rObj)
expected_op = Range(3, 12)
self.assertTrue(combined_obj.is_equal_to(expected_op))
def test_touching(self):
self.assertTrue(self.rngObj.is_touching(Range(3)))
self.assertTrue(self.rngObj.is_touching(Range(8, 12)))
self.assertFalse(self.rngObj.is_touching(Range(6)))
self.assertFalse(self.rngObj.is_touching(Range(5, 10)))
def test_disjoint(self):
self.assertTrue(self.rngObj.is_disjoint(Range(-4, 2)))
self.assertTrue(self.rngObj.is_disjoint(Range(8, 10)))
self.assertFalse(self.rngObj.is_disjoint(Range(1, 4)))
self.assertFalse(self.rngObj.is_disjoint(Range(5)))
wallet = []
wallet.append(
PredatoryCreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500, 0.0825))
wallet.append(
PredatoryCreditCard('John Bowman', 'California Federal',
'3485 0399 3395 1954', 3500, 0.0800))
wallet.append(
PredatoryCreditCard('John Bowman', 'California Finance',
'5391 0375 9387 5309', 5000, 0.0750))
for val in range(1, 17):
wallet[0].charge(val)
wallet[1].charge(2 * val)
wallet[2].charge(3 * val)
for c in Range(3):
wallet[c].process_month()
print('Customer =', wallet[c].get_customer())
print('Bank =', wallet[c].get_bank())
print('Account =', wallet[c].get_account())
print('Limit =', wallet[c].get_limit())
print('Balance =', wallet[c].get_balance())
while wallet[c].get_balance() > 100:
wallet[c].make_payment(100)
print('New balance =', wallet[c].get_balance())
print()
"""
Customer = John Bowman
Bank = California Savings
Account = 5391 0375 9387 5309
Limit = 2500
def test_length(self):
self.assertEqual(self.rngObj.length(), 5)
self.assertEqual(Range(-2, 5).length(), 7)
self.assertEqual(Range(3, 9).length(), 6)
def test_is_less_than(self):
self.assertTrue(self.rngObj.is_less_than(Range(4, 12)))
self.assertTrue(self.rngObj.is_less_than(Range(3, 10)))
self.assertFalse(self.rngObj.is_less_than(Range(3, 6)))
self.assertFalse(self.rngObj.is_less_than(Range(2, 4)))
def setUp(self):
self.rngObj = Range(3, 8)
def valueInUnorderedRange(value, maxOrMin, minOrMax):
if maxOrMin > minOrMax:
range = Range(min=minOrMax, max=maxOrMin)
else:
range = Range(min=maxOrMin, max=minOrMax)
return range.checkValueInRange(value=value)
def yInRange(self, y):
yMin = min((point.y for point in self._listOfPoints))
yMax = max((point.y for point in self._listOfPoints))
return Range(min=yMin, max=yMax).checkValueInRange(value=y)
def xInRange(self, x):
return Range(min=self._listOfPoints[0].x,
max=self._listOfPoints[-1].x).checkValueInRange(value=x)
def __init__(self, mintime, maxtime):
self.timerange = Range(mintime, maxtime)
def notify (self, event):
"""S.notify (...) -> None
Notifies the Scale about an event.
"""
if not self.sensitive:
return
if event.signal in SIGNALS_MOUSE:
eventarea = self.rect_to_client ()
if event.signal == SIG_MOUSEDOWN:
if eventarea.collidepoint (event.data.pos):
self.focus = True
if event.data.button == 1:
# Guarantee a correct look, if the signal
# handlers run a long time
self.state = STATE_ACTIVE
self.run_signal_handlers (SIG_MOUSEDOWN, event.data)
if event.data.button == 1: # Only react upon left clicks.
self.__click = True
val = self._get_value_from_coords (eventarea,
event.data.pos)
if val != self.value:
self.value = val
# Mouse wheel.
elif event.data.button == 4:
val = self.value - 2 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
elif event.data.button == 5:
val = self.value + 2 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
event.handled = True
elif event.signal == SIG_MOUSEUP:
if eventarea.collidepoint (event.data.pos):
if event.data.button == 1:
if self.state == STATE_ACTIVE:
self.state = STATE_ENTERED
else:
self.state = STATE_NORMAL
self.__click = False
self.run_signal_handlers (SIG_MOUSEUP, event.data)
event.handled = True
elif (event.data.button == 1) and self.__click:
self.state = STATE_NORMAL
self.__click = False
elif event.signal == SIG_MOUSEMOVE:
if eventarea.collidepoint (event.data.pos):
self.focus = True
self.run_signal_handlers (SIG_MOUSEMOVE, event.data)
if self.__click and self.focus:
val = self._get_value_from_coords (eventarea,
event.data.pos)
if val != self.value:
self.value = val
self.entered = True
event.handled = True
else:
self.entered = False
elif (event.signal == SIG_KEYDOWN) and self.focus:
if event.data.key in (K_KP_PLUS, K_PLUS, K_RIGHT, K_DOWN):
self.increase ()
event.handled = True
elif event.data.key in (K_KP_MINUS, K_MINUS, K_LEFT, K_UP):
self.decrease ()
event.handled = True
elif event.data.key == K_PAGEUP:
val = self.value - 10 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
event.handled = True
elif event.data.key == K_PAGEDOWN:
val = self.value + 10 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
event.handled = True
elif event.data.key == K_END:
self.value = self.maximum
event.handled = True
elif event.data.key == K_HOME:
self.value = self.minimum
event.handled = True
Range.notify (self, event)
class TestRange:
@pytest.mark.parametrize("range_obj, value, expected_op",
[(Range(3, 7), 6, True), (Range(2, 8), 5, True),
(Range(7), 4, True), (Range(-4, 0), 1, False),
(Range(3, 5), 2, False), (Range(6), 7, False)])
def test_contains(self, range_obj, value, expected_op):
assert range_obj.contains(value) == expected_op
@pytest.mark.parametrize("range_obj, sub_range, expected_op",
[(Range(3, 7), Range(5), True),
(Range(4, 8), Range(5, 10), True),
(Range(5), Range(3, 6), True),
(Range(-5, 2), Range(3, 8), False),
(Range(2), Range(7, 10), False)])
def test_overlaps(self, range_obj, sub_range, expected_op):
assert range_obj.overlaps(sub_range) == expected_op
@pytest.mark.parametrize("range_obj, super_range, expected_op",
[(Range(4, 6), Range(2, 7), True),
(Range(3), Range(8), True),
(Range(5), Range(-1, 8), True),
(Range(3), Range(1, 5), False),
(Range(2), Range(4, 9), False),
(Range(7, 11), Range(3), False)])
def test_sub_range(self, range_obj, super_range, expected_op):
assert range_obj.is_sub_range(super_range) == expected_op
@pytest.mark.parametrize("range_obj, range_obj2, expected_op",
[(Range(3, 7), Range(2), True),
(Range(5), Range(7, 10), True),
(Range(-1, 3), Range(4, 8), True),
(Range(3, 7), Range(5), False),
(Range(8), Range(7, 10), False),
(Range(-1, 5), Range(3, 6), False)])
def test_is_disjoint(self, range_obj, range_obj2, expected_op):
assert range_obj.is_disjoint(range_obj2) == expected_op
@pytest.mark.parametrize("range_obj, range_obj2, expected_op",
[(Range(3, 6), Range(3), True),
(Range(7), Range(7, 10), True),
(Range(8), Range(5), False),
(Range(1, 4), Range(5, 8), False)])
def test_is_touching(self, range_obj, range_obj2, expected_op):
assert range_obj.is_touching(range_obj2) == expected_op
@pytest.mark.parametrize("range_obj, range_obj2, expected_range",
[(Range(2, 7), Range(5), Range(7)),
(Range(3, 7), Range(5, 10), Range(3, 10)),
(Range(4, 7), Range(3, 6), Range(3, 7))])
def test_combine(self, range_obj, range_obj2, expected_range):
combined_range = range_obj.combine(range_obj2)
assert combined_range.start == expected_range.start and combined_range.end == expected_range.end
@pytest.mark.parametrize("range_obj, range_obj2, expected_op",
[(Range(3, 7), Range(3, 7), True),
(Range(-1, 4), Range(3), False),
(Range(5, 9), Range(5, 10), False)])
def test_is_equal_to(self, range_obj, range_obj2, expected_op):
assert range_obj.is_equal_to(range_obj2) == expected_op
@pytest.mark.parametrize("range_obj, range_obj2, expected_op",
[(Range(3, 7), Range(4, 9), True),
(Range(4, 6), Range(4, 8), True),
(Range(5, 6), Range(4, 6), False),
(Range(2, 11), Range(9), False)])
def test_is_less_than(self, range_obj, range_obj2, expected_op):
assert range_obj.is_less_than(range_obj2) == expected_op
@pytest.mark.parametrize("range_obj, range_obj2, expected_op",
[(Range(4, 9), Range(3, 6), True),
(Range(2, 7), Range(2, 5), True),
(Range(2, 7), Range(2, 8), False)])
def test_is_more_than(self, range_obj, range_obj2, expected_op):
assert range_obj.is_more_than(range_obj2) == expected_op
@pytest.mark.parametrize("rObj, expected_len", [(Range(7), 7),
(Range(3, 5), 2),
(Range(4, 9), 5)])
def test_length(self, rObj, expected_len):
assert rObj.length() == expected_len
@pytest.mark.parametrize("given_range, n, expected_range",
[(Range(3, 7), 2, Range(5, 9)),
(Range(5, 9), -3, Range(2, 6))])
def test_shift(self, given_range, n, expected_range):
given_range.shift(n)
assert given_range.start == expected_range.start and given_range.end == expected_range.end
@pytest.mark.parametrize("given_range, n, expected_range",
[(Range(2, 6), 3, Range(2, 9)),
(Range(3, 4), 0, Range(3, 4))])
def test_rshift(self, given_range, n, expected_range):
given_range.rshift(n)
assert given_range.start == expected_range.start and given_range.end == expected_range.end
@pytest.mark.parametrize("given_range, n, expected_range",
[(Range(2, 6), 3, Range(5, 6)),
(Range(3, 4), 0, Range(3, 4))])
def test_lshift(self, given_range, n, expected_range):
given_range.lshift(n)
assert given_range.start == expected_range.start and given_range.end == expected_range.end
@pytest.mark.parametrize("given_range, n , expected_range",
[(Range(2, 5), 1, Range(3, 4)),
(Range(2, 6), 4, Range(0, 0)),
(Range(2, 5), -3, Range(-1, 8))])
def test_squeeze(self, given_range, n, expected_range):
given_range.squeeze(n)
assert given_range.start == expected_range.start and given_range.end == expected_range.end
@pytest.mark.parametrize("range_obj", [(Range(3, 5))])
def test_reset(self, range_obj):
range_obj.reset()
assert range_obj.start == 0 and range_obj.end == 0
class TestRange(unittest.TestCase):
def setUp(self):
self.rngObj = Range(3, 8)
def test_contains(self):
self.assertTrue(self.rngObj.contains(4))
self.assertTrue(self.rngObj.contains(7))
self.assertFalse(self.rngObj.contains(-1))
self.assertFalse(self.rngObj.contains(12))
def test_overlaps(self):
self.assertTrue(self.rngObj.overlaps(Range(1, 4)))
self.assertTrue(self.rngObj.overlaps(Range(5)))
self.assertFalse(self.rngObj.overlaps(Range(-4, 2)))
self.assertFalse(self.rngObj.overlaps(Range(8, 10)))
def test_sub_range(self):
self.assertTrue(self.rngObj.is_sub_range(Range(2, 9)))
self.assertTrue(self.rngObj.is_sub_range(Range(-4, 12)))
self.assertFalse(self.rngObj.is_sub_range(Range(1, 6)))
self.assertFalse(self.rngObj.is_sub_range(Range(2, 4)))
def test_disjoint(self):
self.assertTrue(self.rngObj.is_disjoint(Range(-4, 2)))
self.assertTrue(self.rngObj.is_disjoint(Range(8, 10)))
self.assertFalse(self.rngObj.is_disjoint(Range(1, 4)))
self.assertFalse(self.rngObj.is_disjoint(Range(5)))
def test_touching(self):
self.assertTrue(self.rngObj.is_touching(Range(3)))
self.assertTrue(self.rngObj.is_touching(Range(8, 12)))
self.assertFalse(self.rngObj.is_touching(Range(6)))
self.assertFalse(self.rngObj.is_touching(Range(5, 10)))
def test_combine_true(self):
rObj = Range(5, 12)
combined_obj = self.rngObj.combine(rObj)
expected_op = Range(3, 12)
self.assertTrue(combined_obj.is_equal_to(expected_op))
def test_combine_disjoint_ranges(self):
rObj = Range(-5, 1)
combined_obj = self.rngObj.combine(rObj)
expected_op = Range(0, 0)
self.assertTrue(combined_obj.is_equal_to(expected_op))
def test_is_equal_to(self):
self.assertTrue(self.rngObj.is_equal_to(Range(3, 8)))
self.assertFalse(self.rngObj.is_equal_to(Range(3, 7)))
def test_is_less_than(self):
self.assertTrue(self.rngObj.is_less_than(Range(4, 12)))
self.assertTrue(self.rngObj.is_less_than(Range(3, 10)))
self.assertFalse(self.rngObj.is_less_than(Range(3, 6)))
self.assertFalse(self.rngObj.is_less_than(Range(2, 4)))
def test_is_more_than(self):
self.assertTrue(self.rngObj.is_more_than(Range(3, 6)))
self.assertTrue(self.rngObj.is_more_than(Range(2, 6)))
self.assertFalse(self.rngObj.is_more_than(Range(3, 12)))
self.assertFalse(self.rngObj.is_more_than(Range(3, 10)))
def test_length(self):
self.assertEqual(self.rngObj.length(), 5)
self.assertEqual(Range(-2, 5).length(), 7)
self.assertEqual(Range(3, 9).length(), 6)
def test_combine_disjoint_ranges(self):
rObj = Range(-5, 1)
combined_obj = self.rngObj.combine(rObj)
expected_op = Range(0, 0)
self.assertTrue(combined_obj.is_equal_to(expected_op))
def notify(self, event):
"""S.notify (...) -> None
Notifies the Scale about an event.
"""
if not self.eventarea or not self.sensitive:
return
if event.signal == SIG_MOUSEDOWN:
if self.eventarea.collidepoint(event.data.pos):
if base.debug:
print "Scale.MOUSEDOWN"
self.focus = True
if event.data.button == 1:
# Guarantee a correct look, if the signal handlers run a
# long time
self.state = STATE_ACTIVE
self.run_signal_handlers(SIG_MOUSEDOWN)
if event.data.button == 1: # Only react upon left clicks.
self.__click = True
val = self.get_value_from_coords(event.data.pos)
if val != self.value:
self.value = val
# Mouse wheel.
elif event.data.button == 4:
val = self.value - 2 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
elif event.data.button == 5:
val = self.value + 2 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
elif event.signal == SIG_MOUSEUP:
if self.eventarea.collidepoint(event.data.pos):
if base.debug:
print "Scale.MOUSEUP"
if event.data.button == 1:
if self.state == STATE_ACTIVE:
self.state = STATE_ENTERED
else:
self.state = STATE_NORMAL
self.__click = False
self.run_signal_handlers(SIG_MOUSEUP)
elif (event.data.button == 1) and self.__click:
self.state = STATE_NORMAL
self.__click = False
elif event.signal == SIG_MOUSEMOVE:
if self.eventarea.collidepoint(event.data.pos):
if base.debug:
print "Scale.MOUSEMOVE (inner)"
self.focus = True
if self.state == STATE_NORMAL:
self.state = STATE_ENTERED
self.run_signal_handlers(SIG_MOUSEMOVE)
if self.__click and self.focus:
val = self.get_value_from_coords(event.data.pos)
if val != self.value:
self.value = val
elif self.state == STATE_ENTERED:
if base.debug:
print "Scale.MOUSEMOVE (outer)"
self.state = STATE_NORMAL
elif (event.signal == SIG_KEYDOWN) and self.focus:
if event.data.key in (
pygame.locals.K_KP_PLUS,
pygame.locals.K_PLUS,
pygame.locals.K_RIGHT,
pygame.locals.K_DOWN,
):
self.increase()
elif event.data.key in (
pygame.locals.K_KP_MINUS,
pygame.locals.K_MINUS,
pygame.locals.K_LEFT,
pygame.locals.K_UP,
):
self.decrease()
elif event.data.key == pygame.locals.K_PAGEUP:
val = self.value - 10 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
elif event.data.key == pygame.locals.K_PAGEDOWN:
val = self.value + 10 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
elif event.data.key == pygame.locals.K_END:
self.value = self.maximum
elif event.data.key == pygame.locals.K_HOME:
self.value = self.minimum
Range.notify(self, event)
def test_is_equal_to(self):
self.assertTrue(self.rngObj.is_equal_to(Range(3, 8)))
self.assertFalse(self.rngObj.is_equal_to(Range(3, 7)))
def notify (self, event):
"""S.notify (...) -> None
Notifies the ScrollBar about an event.
"""
if not self.sensitive:
return
if event.signal in SIGNALS_MOUSE:
eventarea = self.rect_to_client ()
collision = eventarea.collidepoint (event.data.pos)
if event.signal == SIG_MOUSEDOWN and collision:
self.focus = True
# Act only on left clicks or scrollwheel events.
if event.data.button == 1:
self.state = STATE_ACTIVE
self.run_signal_handlers (SIG_MOUSEDOWN, event.data)
if event.data.button == 1:
buttons = self._get_button_coords (eventarea)
if self._check_collision (event.data.pos, buttons[0]):
self._buttondec = True
self._buttoninc = False
self._click = False
self.decrease ()
elif self._check_collision (event.data.pos, buttons[1]):
self._buttoninc = True
self._buttondec = False
self._click = False
self.increase ()
else:
self._click = True
self._buttondec = False
self._buttoninc = False
val = self._get_value_from_coords (eventarea,
event.data.pos)
if val != self.value:
self.value = val
# Mouse wheel.
elif event.data.button == 4:
self.decrease ()
elif event.data.button == 5:
self.increase ()
event.handled = True
elif event.signal == SIG_MOUSEMOVE:
dirty = False
if collision:
self.focus = True
if self.state == STATE_NORMAL:
self.state = STATE_ENTERED
self.run_signal_handlers (SIG_MOUSEMOVE, event.data)
buttons = self._get_button_coords (eventarea)
if not self._check_collision (event.data.pos, buttons[0]) \
and self._buttondec:
self._buttondec = False
dirty = True
if not self._check_collision (event.data.pos, buttons[1]) \
and self._buttoninc:
self._buttoninc = False
dirty = True
if self._click:
val = self._get_value_from_coords (eventarea,
event.data.pos)
if val != self.value:
self.value = val
dirty = False
self.dirty = dirty
event.handled = True
elif self.state == STATE_ENTERED:
self.state = STATE_NORMAL
elif event.signal == SIG_MOUSEUP:
if self._click or self._buttoninc or self._buttondec:
self._buttondec = False
self._buttoninc = False
self._click = False
if collision:
if event.data.button == 1:
if self.state == STATE_ACTIVE:
self.state = STATE_ENTERED
self.run_signal_handlers (SIG_MOUSEUP, event.data)
event.handled = True
else:
self.state = STATE_NORMAL
# Reset timer
self._timer = _TIMER
# The user holds the mouse clicked over one button.
elif (self._buttondec or self._buttoninc) and \
(event.signal == SIG_TICK):
# Wait half a second before starting to in/decrease.
if self._timer > 0:
self._timer -= 1
else:
if self._buttondec:
self.decrease ()
elif self._buttoninc:
self.increase ()
# Keyboard activation.
elif (event.signal == SIG_KEYDOWN) and self.focus:
if event.data.key in (K_KP_PLUS, K_PLUS, K_RIGHT, K_DOWN):
self.increase ()
event.handled = True
elif event.data.key in (K_KP_MINUS, K_MINUS, K_LEFT, K_UP):
self.decrease ()
event.handled = True
elif event.data.key == K_PAGEUP:
val = self.value - 10 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
event.handled = True
elif event.data.key == K_PAGEDOWN:
val = self.value + 10 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
event.handled = True
elif event.data.key == K_END:
self.value = self.maximum
event.handled = True
elif event.data.key == K_HOME:
self.value = self.minimum
event.handled = True
Range.notify (self, event)
def test_is_more_than(self):
self.assertTrue(self.rngObj.is_more_than(Range(3, 6)))
self.assertTrue(self.rngObj.is_more_than(Range(2, 6)))
self.assertFalse(self.rngObj.is_more_than(Range(3, 12)))
self.assertFalse(self.rngObj.is_more_than(Range(3, 10)))
def test_sub_range(self):
self.assertTrue(self.rngObj.is_sub_range(Range(2, 9)))
self.assertTrue(self.rngObj.is_sub_range(Range(-4, 12)))
self.assertFalse(self.rngObj.is_sub_range(Range(1, 6)))
self.assertFalse(self.rngObj.is_sub_range(Range(2, 4)))
def range(low, high):
from Range import Range
return Range(low, high)
def notify (self, event):
"""S.notify (...) -> None
Notifies the ScrollBar about an event.
"""
if not self.eventarea or not self.sensitive:
return
if event.signal == SIG_MOUSEDOWN and \
self.eventarea.collidepoint (event.data.pos):
if base.debug: print "ScrollBar.MOUSEDOWN"
self.focus = True
# Act only on left clicks or scrollwheel events.
if event.data.button == 1:
self.state = STATE_ACTIVE
self.run_signal_handlers (SIG_MOUSEDOWN)
if event.data.button == 1:
buttons = self.get_button_coords ()
if self._check_collision (event.data.pos, buttons[0]):
self._button_dec = True
self._button_inc = False
self._click = False
self.decrease ()
elif self._check_collision (event.data.pos, buttons[1]):
self._button_inc = True
self._button_dec = False
self._click = False
self.increase ()
else:
self._click = True
self._button_dec = False
self._button_inc = False
val = self.get_value_from_coords (event.data.pos)
if val != self.value:
self.value = val
# Mouse wheel.
elif event.data.button == 4:
self.decrease ()
elif event.data.button == 5:
self.increase ()
elif event.signal == SIG_MOUSEMOVE:
if self.eventarea.collidepoint (event.data.pos):
if base.debug: print "ScrollBar.MOUSEMOVE (inner)"
self.focus = True
if self.state == STATE_NORMAL:
self.state = STATE_ENTERED
self.run_signal_handlers (SIG_MOUSEMOVE)
buttons = self.get_button_coords ()
if not self._check_collision (event.data.pos, buttons[0]):
self._button_dec = False
self.dirty = True
if not self._check_collision (event.data.pos, buttons[1]):
self._button_inc = False
self.dirty = True
if self._click:
val = self.get_value_from_coords (event.data.pos)
if val != self.value:
self.value = val
elif self.state == STATE_ENTERED:
if base.debug: print "ScrollBar.MOUSEMOVE (outer)"
self.state = STATE_NORMAL
elif event.signal == SIG_MOUSEUP:
if self.rect.collidepoint (event.data.pos):
if base.debug: print "ScrollBar.MOUSEUP"
if event.data.button == 1:
if self.state == STATE_ACTIVE:
self.state = STATE_ENTERED
self.run_signal_handlers (SIG_MOUSEUP)
else:
self.state = STATE_NORMAL
if self._click or self._button_inc or self._button_dec:
self._button_dec = False
self._button_inc = False
self._click = False
# The user holds the mouse clicked over one button.
elif event.signal == SIG_TICK:
if self._button_dec:
self.decrease ()
elif self._button_inc:
self.increase ()
# Keyboard activation.
elif (event.signal == SIG_KEYDOWN) and self.focus:
if event.data.key in (pygame.locals.K_KP_PLUS,
pygame.locals.K_PLUS, pygame.locals.K_RIGHT,
pygame.locals.K_DOWN):
self.increase ()
elif event.data.key in (pygame.locals.K_KP_MINUS,
pygame.locals.K_MINUS,
pygame.locals.K_LEFT, pygame.locals.K_UP):
self.decrease ()
elif event.data.key == pygame.locals.K_PAGEUP:
val = self.value - 10 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
elif event.data.key == pygame.locals.K_PAGEDOWN:
val = self.value + 10 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
elif event.data.key == pygame.locals.K_END:
self.value = self.maximum
elif event.data.key == pygame.locals.K_HOME:
self.value = self.minimum
Range.notify (self, event)
def test_overlaps(self):
self.assertTrue(self.rngObj.overlaps(Range(1, 4)))
self.assertTrue(self.rngObj.overlaps(Range(5)))
self.assertFalse(self.rngObj.overlaps(Range(-4, 2)))
self.assertFalse(self.rngObj.overlaps(Range(8, 10)))
def notify(self, event):
"""S.notify (...) -> None
Notifies the Scale about an event.
"""
if not self.sensitive:
return
if event.signal in SIGNALS_MOUSE:
eventarea = self.rect_to_client()
if event.signal == SIG_MOUSEDOWN:
if eventarea.collidepoint(event.data.pos):
self.focus = True
if event.data.button == 1:
# Guarantee a correct look, if the signal
# handlers run a long time
self.state = STATE_ACTIVE
self.run_signal_handlers(SIG_MOUSEDOWN, event.data)
if event.data.button == 1: # Only react upon left clicks.
self.__click = True
val = self._get_value_from_coords(
eventarea, event.data.pos)
if val != self.value:
self.value = val
# Mouse wheel.
elif event.data.button == 4:
val = self.value - 2 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
elif event.data.button == 5:
val = self.value + 2 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
event.handled = True
elif event.signal == SIG_MOUSEUP:
if eventarea.collidepoint(event.data.pos):
if event.data.button == 1:
if self.state == STATE_ACTIVE:
self.state = STATE_ENTERED
else:
self.state = STATE_NORMAL
self.__click = False
self.run_signal_handlers(SIG_MOUSEUP, event.data)
event.handled = True
elif (event.data.button == 1) and self.__click:
self.state = STATE_NORMAL
self.__click = False
elif event.signal == SIG_MOUSEMOVE:
if eventarea.collidepoint(event.data.pos):
self.focus = True
self.run_signal_handlers(SIG_MOUSEMOVE, event.data)
if self.__click and self.focus:
val = self._get_value_from_coords(
eventarea, event.data.pos)
if val != self.value:
self.value = val
self.entered = True
event.handled = True
else:
self.entered = False
elif (event.signal == SIG_KEYDOWN) and self.focus:
if event.data.key in (K_KP_PLUS, K_PLUS, K_RIGHT, K_DOWN):
self.increase()
event.handled = True
elif event.data.key in (K_KP_MINUS, K_MINUS, K_LEFT, K_UP):
self.decrease()
event.handled = True
elif event.data.key == K_PAGEUP:
val = self.value - 10 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
event.handled = True
elif event.data.key == K_PAGEDOWN:
val = self.value + 10 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
event.handled = True
elif event.data.key == K_END:
self.value = self.maximum
event.handled = True
elif event.data.key == K_HOME:
self.value = self.minimum
event.handled = True
Range.notify(self, event)
help='Sort movies by category. Possible categories: ID, Title, Year, Runtime, Genre, Director,\
Actors, Writer, Language, Country, Won_oscars, Oscars_nominations, Another_wins,\
Another_nominations, IMDb_rating, IMDb_votes, Box_office. Its possible to choose multiple\
categories, movies will be displayed in order in witch categories are given. Command\
returns movie title and chosen category / ies.')
group.add_argument('-f', '--filter_by', type=str, metavar=('Category', 'Key'), nargs=2, action='append',
help="Filter movie by category. Possible categories: Actor, Country, Director, Genre, Language,\
Writer. Multiple categories can be chosen but any can't be repeated. For filtering by multiple\
category insert argument multiple times like: -f Category1 Key1 -f Category2 Key2. Key should\
be writen with a capital letter. Command returns movie title and chosen category/ies.")
group.add_argument('-dw', '--nominated_for_oscar_dont_win', action='store_true',
help="Command returns movies titles that was nominated for oscar but didn't win any.")
group.add_argument('-wm', '--win_more_than', type=float, choices=[Range(0.0, 1.0)], nargs='?', default=0.8,
metavar='Value from range <0, 1>',
help="Command returns movies titles that win more then Value nominations. All wins and nominations\
(oscars and others awards) are taken in consideration.")
group.add_argument('-em', '--earned_more_than', type=int, nargs='?', const=100000000, metavar='Amount (int)',
help="Command returns movies that earn more than Amount. Default value is 1,000,000.\
Movie title and how much movie earned will be displayed.")
group.add_argument('-c', '--compare_by', type=str, metavar=('Category', 'Title1 Title2 Title3'), nargs='*',
help="Compare movies by. Possible categories: Runtime, All_awards_won, Box_office, IMDb_rating.\
Command returns movie title of the best movie in this category with value of the chosen category.")
group.add_argument('-a', '--add', type=str, metavar='Title', nargs='*',
help="Add movie to program database by title. Data about movie will be fetch. It is possible to add\
multiple movies with one command, just add another titles after first one, like:\
def notify(self, event):
"""S.notify (...) -> None
Notifies the ScrollBar about an event.
"""
if not self.sensitive:
return
if event.signal in SIGNALS_MOUSE:
eventarea = self.rect_to_client()
collision = eventarea.collidepoint(event.data.pos)
if event.signal == SIG_MOUSEDOWN and collision:
self.focus = True
# Act only on left clicks or scrollwheel events.
if event.data.button == 1:
self.state = STATE_ACTIVE
self.run_signal_handlers(SIG_MOUSEDOWN, event.data)
if event.data.button == 1:
buttons = self._get_button_coords(eventarea)
if self._check_collision(event.data.pos, buttons[0]):
self._buttondec = True
self._buttoninc = False
self._click = False
self.decrease()
elif self._check_collision(event.data.pos, buttons[1]):
self._buttoninc = True
self._buttondec = False
self._click = False
self.increase()
else:
self._click = True
self._buttondec = False
self._buttoninc = False
val = self._get_value_from_coords(
eventarea, event.data.pos)
if val != self.value:
self.value = val
# Mouse wheel.
elif event.data.button == 4:
self.decrease()
elif event.data.button == 5:
self.increase()
event.handled = True
elif event.signal == SIG_MOUSEMOVE:
dirty = False
if collision:
self.focus = True
if self.state == STATE_NORMAL:
self.state = STATE_ENTERED
self.run_signal_handlers(SIG_MOUSEMOVE, event.data)
buttons = self._get_button_coords(eventarea)
if not self._check_collision (event.data.pos, buttons[0]) \
and self._buttondec:
self._buttondec = False
dirty = True
if not self._check_collision (event.data.pos, buttons[1]) \
and self._buttoninc:
self._buttoninc = False
dirty = True
if self._click:
val = self._get_value_from_coords(
eventarea, event.data.pos)
if val != self.value:
self.value = val
dirty = False
self.dirty = dirty
event.handled = True
elif self.state == STATE_ENTERED:
self.state = STATE_NORMAL
elif event.signal == SIG_MOUSEUP:
if self._click or self._buttoninc or self._buttondec:
self._buttondec = False
self._buttoninc = False
self._click = False
if collision:
if event.data.button == 1:
if self.state == STATE_ACTIVE:
self.state = STATE_ENTERED
self.run_signal_handlers(SIG_MOUSEUP, event.data)
event.handled = True
else:
self.state = STATE_NORMAL
# Reset timer
self._timer = _TIMER
# The user holds the mouse clicked over one button.
elif (self._buttondec or self._buttoninc) and \
(event.signal == SIG_TICK):
# Wait half a second before starting to in/decrease.
if self._timer > 0:
self._timer -= 1
else:
if self._buttondec:
self.decrease()
elif self._buttoninc:
self.increase()
# Keyboard activation.
elif (event.signal == SIG_KEYDOWN) and self.focus:
if event.data.key in (K_KP_PLUS, K_PLUS, K_RIGHT, K_DOWN):
self.increase()
event.handled = True
elif event.data.key in (K_KP_MINUS, K_MINUS, K_LEFT, K_UP):
self.decrease()
event.handled = True
elif event.data.key == K_PAGEUP:
val = self.value - 10 * self.step
if val > self.minimum:
self.value = val
else:
self.value = self.minimum
event.handled = True
elif event.data.key == K_PAGEDOWN:
val = self.value + 10 * self.step
if val < self.maximum:
self.value = val
else:
self.value = self.maximum
event.handled = True
elif event.data.key == K_END:
self.value = self.maximum
event.handled = True
elif event.data.key == K_HOME:
self.value = self.minimum
event.handled = True
Range.notify(self, event)
