def test_copy_to_system(self): # Test with format_unicode. text1 = u"unicode text" c = Clipboard(contents={format_unicode: text1}) c.copy_to_system(clear=True) self.assertEqual(Clipboard.get_system_text(), text1) # Test with format_text. Text string used deliberately here; # get_system_text() should returns those. text2 = u"text" c = Clipboard(contents={format_text: text2}) c.copy_to_system(clear=True) self.assertEqual(Clipboard.get_system_text(), text2) # Test with text. text3 = u"testing" c = Clipboard(text=text3) c.copy_to_system(clear=True) self.assertEqual(Clipboard.get_system_text(), text3) # Test with an empty Clipboard instance. c = Clipboard() c.copy_to_system(clear=False) self.assertEqual(Clipboard.get_system_text(), text3) c.copy_to_system(clear=True) self.assertEqual(Clipboard.get_system_text(), u"")
def test_get_format(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertRaises(ValueError, c.get_format, format_unicode) self.assertRaises(ValueError, c.get_format, format_text) self.assertRaises(ValueError, c.get_format, format_hdrop) # Test with one format. text1 = u"unicode text" c = Clipboard(contents={format_unicode: text1}) self.assertEqual(c.get_format(format_unicode), text1) self.assertRaises(ValueError, c.get_format, format_text) self.assertRaises(ValueError, c.get_format, format_hdrop) # Test with two formats. text2 = b"text" c = Clipboard(contents={format_unicode: text1, format_text: text2}) self.assertEqual(c.get_format(format_unicode), text1) self.assertEqual(c.get_format(format_text), text2) self.assertRaises(ValueError, c.get_format, format_hdrop) # Test with format_hdrop. with NamedTemporaryFile() as f: c = Clipboard(contents={format_hdrop: f.name}) self.assertRaises(ValueError, c.get_format, format_unicode) self.assertRaises(ValueError, c.get_format, format_text) self.assertEqual(c.get_format(format_hdrop), (f.name,))
def test_backwards_compatibility(self): # The multi-platform class should be backwards compatible with the # Windows-only Clipboard class, at least for the constructor. text = u"unicode text" c = Clipboard(contents={13: text}) c.copy_to_system() self.assertEqual(Clipboard.get_system_text(), text) # Test with the CF_TEXT format (1) text = "text" c = Clipboard(contents={1: text}) c.copy_to_system() self.assertEqual(Clipboard.get_system_text(), text)
def test_copy_from_system(self): text = "testing" Clipboard.set_system_text(text) c = Clipboard() # Test the method with clear=False (default) c.copy_from_system(clear=False) self.assertEqual(c.text, text) self.assertEqual(Clipboard.get_system_text(), text) # Test again with clear=True c = Clipboard() c.copy_from_system(clear=True) self.assertEqual(c.text, text) self.assertEqual(Clipboard.get_system_text(), "")
def select_string(include_quotes): mouse("left/3").execute() clipboard = Clipboard() saved_text = clipboard.get_system_text() clipboard.set_system_text('') left_counter = 0 while left_counter < 50: key("s-left, c-c/3").execute() left_counter += 1 if clipboard.get_system_text().startswith("\""): break key("left").execute() move_right = left_counter if not include_quotes: move_right -= 1 key("right").execute() key("s-right:%s" % move_right).execute() right_counter = 0 while right_counter < 50: key("s-right, c-c/3").execute() right_counter += 1 if clipboard.get_system_text().endswith("\""): break if not include_quotes: key("s-left").execute() clipboard.set_text(saved_text) clipboard.copy_to_system()
def stoosh_keep_clipboard(nnavi500, nexus): if nnavi500 == 1: Key("c-c").execute() else: max_tries = 20 cb = Clipboard(from_system=True) Key("c-c").execute() key = str(nnavi500) for i in range(0, max_tries): failure = False try: # time for keypress to execute time.sleep( settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) nexus.clip[key] = Clipboard.get_system_text() utilities.save_json_file( nexus.clip, settings.SETTINGS["paths"]["SAVED_CLIPBOARD_PATH"]) except Exception: failure = True utilities.simple_log() if not failure: break cb.copy_to_system()
def test_set_text(self): c = Clipboard() text = "test" c.set_text(text) self.assertTrue(c.has_text()) self.assertEqual(c.get_text(), text) self.assertEqual(c.text, text)
def test_set_format(self): # Test with one format. text1 = u"unicode text" c = Clipboard() c.set_format(format_unicode, text1) self.assertTrue(c.has_format(format_unicode)) self.assertEqual(c.get_format(format_unicode), text1) self.assertFalse(c.has_format(format_text)) self.assertRaises(ValueError, c.get_format, format_text) # Test with two formats. text2 = b"text" c.set_format(format_text, text2) self.assertTrue(c.has_format(format_unicode)) self.assertEqual(c.get_format(format_unicode), text1) self.assertTrue(c.has_format(format_text)) self.assertEqual(c.get_format(format_text), text2) # Setting a format to None removes the format's content from the # instance. c.set_format(format_text, None) self.assertFalse(c.has_format(format_text)) self.assertRaises(ValueError, c.get_format, format_text) c.set_format(format_unicode, None) self.assertFalse(c.has_format(format_unicode)) self.assertRaises(ValueError, c.get_format, format_unicode)
def test_from_system_argument(self): # Test the optional from_system argument of Clipboard.__init__ text = "something" Clipboard.set_system_text(text) c = Clipboard(from_system=True) self.assertEqual(c.text, text) self.assertTrue(c.has_text())
def test_get_format(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertRaises(ValueError, c.get_format, format_unicode) self.assertRaises(ValueError, c.get_format, format_text) # Test with one format. text1 = u"unicode text" c = Clipboard(contents={format_unicode: text1}) self.assertEqual(c.get_format(format_unicode), text1) self.assertRaises(ValueError, c.get_format, format_text) # Test with two formats. text2 = b"text" c = Clipboard(contents={format_unicode: text1, format_text: text2}) self.assertEqual(c.get_format(format_unicode), text1) self.assertEqual(c.get_format(format_text), text2)
def duple_keep_clipboard(nnavi50): cb = Clipboard(from_system=True) Key("escape, home, s-end, c-c, end").execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) for i in range(0, nnavi50): Key("enter, c-v").execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) cb.copy_to_system()
def test_has_format(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertFalse(c.has_format(format_unicode)) self.assertFalse(c.has_format(format_text)) self.assertFalse(c.has_format(format_hdrop)) # Test with one format. c = Clipboard(contents={format_unicode: u"unicode text"}) self.assertTrue(c.has_format(format_unicode)) self.assertFalse(c.has_format(format_text)) # Test with two formats. c = Clipboard(contents={format_unicode: u"unicode text", format_text: u"text"}) self.assertTrue(c.has_format(format_unicode)) self.assertTrue(c.has_format(format_text))
def get_selected_text(): clipboard = Clipboard() previous = clipboard.get_system_text() clipboard.set_system_text("") Key("c-c/3").execute() selected = clipboard.get_system_text() clipboard.set_text(previous) clipboard.copy_to_system() return selected
def test_flexible_string_types(self): # This is similar to the clipboard format conversion that Windows # performs when necessary. The Clipboard class should do this # regardless of platform/implementation. # Binary strings used with format_unicode are converted for us. c = Clipboard(contents={format_unicode: b"text"}) self.assertEqual(c.get_format(format_unicode), u"text") c = Clipboard() c.set_format(format_unicode, b"text") self.assertEqual(c.get_format(format_unicode), u"text") # Text strings used with format_text (ANSI) are converted for us. c = Clipboard(contents={format_text: u"text"}) self.assertEqual(c.get_format(format_text), b"text") c = Clipboard() c.set_format(format_text, u"text") self.assertEqual(c.get_format(format_text), b"text")
def _select_and_cut_text(wordCount): """Selects wordCount number of words to the left of the cursor and cuts them out of the text. Returns the text from the system clip board. """ clipboard = Clipboard() clipboard.set_system_text('') Key('cs-left/3:%s/10, c-x/10' % wordCount).execute() return clipboard.get_system_text()
def test_has_text(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertFalse(c.has_text()) # Test with format_unicode only. c = Clipboard(contents={format_unicode: u"unicode text"}) self.assertTrue(c.has_text()) # Test with both text formats. c = Clipboard(contents={ format_unicode: u"unicode text", format_text: b"text" }) self.assertTrue(c.has_text()) # Test with format_text only. c = Clipboard(contents={format_text: b"text"}) self.assertTrue(c.has_text())
def paste_string(content): time.sleep(0.05) cb = Clipboard(from_system=True) try: Clipboard.set_system_text(str(content)) Key("c-v").execute() time.sleep(0.05) cb.copy_to_system() except Exception: return False return True
def test_set_text(self): c = Clipboard() text = "test" c.set_text(text) self.assertTrue(c.has_text()) self.assertEqual(c.get_text(), text) self.assertEqual(c.text, text) # Setting the text to None clears the stored text. c.set_text(None) self.assertFalse(c.has_text()) self.assertIs(c.get_text(), None)
def paste_string(content): cb = Clipboard(from_system=True) time.sleep(SETTINGS["keypress_wait"]) try: Clipboard.set_system_text(str(content)) time.sleep(SETTINGS["keypress_wait"]) Key("c-v").execute() time.sleep(SETTINGS["keypress_wait"]) cb.copy_to_system() except Exception: return False return True
def test_copy_from_system(self): text = "testing" Clipboard.set_system_text(text) c = Clipboard() # Test the method with clear=False (default). c.copy_from_system(clear=False) self.assertEqual(c.text, text) self.assertEqual(Clipboard.get_system_text(), text) # Test again with clear=True. c = Clipboard() c.copy_from_system(clear=True) self.assertEqual(c.text, text) self.assertEqual(Clipboard.get_system_text(), "") # Test formats=format_unicode. # Set the system clipboard before testing. text1 = u"unicode text" c1 = Clipboard(contents={format_unicode: text1}) c1.copy_to_system() c2 = Clipboard() c2.copy_from_system(formats=format_unicode) self.assertTrue(c2.has_format(format_unicode)) self.assertEqual(c2.get_format(format_unicode), text1) # Test formats=format_text. # Set the system clipboard before testing. text2 = b"text" c1 = Clipboard(contents={format_text: text2}) c1.copy_to_system() c2 = Clipboard() c2.copy_from_system(formats=format_text) self.assertTrue(c2.has_format(format_text)) self.assertEqual(c2.get_format(format_text), text2) # Test formats=(format_unicode, format_text). # Set the system clipboard before testing. Use the same string for # both formats so the test will work on all platforms. c1 = Clipboard(contents={ format_text: b"text", format_unicode: u"text" }) c1.copy_to_system() c2 = Clipboard() c2.copy_from_system(formats=(format_unicode, format_text)) self.assertTrue(c2.has_format(format_unicode)) self.assertEqual(c2.get_format(format_unicode), u"text") self.assertTrue(c2.has_format(format_text)) self.assertEqual(c2.get_format(format_text), b"text")
def test_get_available_formats(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertEqual(c.get_available_formats(), []) # Test with one format. c = Clipboard(contents={format_unicode: u"unicode text"}) self.assertEqual(c.get_available_formats(), [format_unicode]) # Test with two formats. c = Clipboard(contents={format_unicode: u"unicode text", format_text: u"text"}) self.assertEqual(c.get_available_formats(), [format_unicode, format_text], "format_unicode should precede format_text") # Test with text formats and one custom format. The preferred text # format should be first on the list. format_custom = 0 c = Clipboard(contents={format_custom: 123, format_unicode: u"unicode text"}) self.assertEqual(c.get_available_formats(), [format_unicode, format_custom], "format_unicode should precede format_custom") c = Clipboard(contents={format_custom: 123, format_text: b"text"}) self.assertEqual(c.get_available_formats(), [format_text, format_custom], "format_text should precede format_custom") # Test with no text format and one custom format. c = Clipboard(contents={format_custom: 123}) self.assertEqual(c.get_available_formats(), [format_custom])
def test_has_text(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertFalse(c.has_text()) # Test with format_unicode only. c = Clipboard(contents={format_unicode: u"unicode text"}) self.assertTrue(c.has_text()) # Test with both text formats. c = Clipboard(contents={format_unicode: u"unicode text", format_text: b"text"}) self.assertTrue(c.has_text()) # Test with format_text only. c = Clipboard(contents={format_text: b"text"}) self.assertTrue(c.has_text()) # Test with format_hdrop only. with NamedTemporaryFile() as f: c = Clipboard(contents={format_hdrop: f.name}) self.assertFalse(c.has_text())
def test_get_text(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertIsNone(c.get_text()) # Test with Unicode text. text1 = u"test" c.set_text(text1) self.assertEqual(c.get_text(), text1) # Test with text set to None. c.set_text(None) self.assertIsNone(c.get_text()) # Test with binary text. text2 = b"test" c.set_text(text2) self.assertEqual(c.get_text(), text2) # Test with format_hdrop. with NamedTemporaryFile() as f: c = Clipboard(contents={format_hdrop: f.name}) self.assertIsNone(c.get_text())
def read_selected(same_is_okay=False): time.sleep(SETTINGS["keypress_wait"]) cb = Clipboard(from_system=True) temporary = None prior_content = None try: prior_content = Clipboard.get_system_text() Clipboard.set_system_text("") Key("c-c").execute() time.sleep(SETTINGS["keypress_wait"]) temporary = Clipboard.get_system_text() cb.copy_to_system() except Exception: return None if prior_content == temporary and not same_is_okay: return None return temporary
def test_get_text(self): # Test with an empty Clipboard instance. c = Clipboard() self.assertIsNone(c.get_text()) # Test with Unicode text. text1 = u"test" c.set_text(text1) self.assertEqual(c.get_text(), text1) # Test with text set to None. c.set_text(None) self.assertIsNone(c.get_text()) # Test with binary text. text2 = b"test" c.set_text(text2) self.assertEqual(c.get_text(), text2)
def test_non_strings(self): # Using non-string objects for text formats raises errors. self.assertRaises(TypeError, Clipboard, {format_text: 0}) self.assertRaises(TypeError, Clipboard, {format_unicode: 0}) self.assertRaises(TypeError, Clipboard, {format_text: object()}) self.assertRaises(TypeError, Clipboard, {format_unicode: object()}) self.assertRaises(TypeError, Clipboard, {format_text: None}) self.assertRaises(TypeError, Clipboard, {format_unicode: None}) c = Clipboard() self.assertRaises(TypeError, c.set_text, 0) self.assertRaises(TypeError, c.set_text, object()) self.assertRaises(TypeError, c.set_format, format_text, 0) self.assertRaises(TypeError, c.set_format, format_text, object()) self.assertRaises(TypeError, c.set_format, format_unicode, 0) self.assertRaises(TypeError, c.set_format, format_unicode, object()) self.assertRaises(TypeError, c.set_system_text, 0) self.assertRaises(TypeError, c.set_system_text, object())
def _select_and_cut_text(wordCount): """Selects wordCount number of words to the left of the cursor and cuts them out of the text. Returns the text from the system clip board. """ clipboard = Clipboard() clipboard.set_system_text('') try: # Try selecting n number of words. Key('ctrl:down, shift:down').execute() Key('left:%s' % wordCount).execute() Key('shift:up').execute() finally: # It is important to make sure that the buttons are released. # Otherwise you get stuck in an unpleasant situation. Key('shift:up, ctrl:up').execute() Pause("10").execute() Key('c-x').execute() # Cut out the selected words. Pause("20").execute() return clipboard.get_system_text()
def read_selected(same_is_okay=False): '''Returns a tuple: (0, "text from system") - indicates success (1, None) - indicates no change (2, None) - indicates clipboard error ''' time.sleep(0.05) cb = Clipboard(from_system=True) temporary = None prior_content = None try: prior_content = Clipboard.get_system_text() Clipboard.set_system_text("") Key("c-c").execute() time.sleep(0.05) temporary = Clipboard.get_system_text() cb.copy_to_system() except Exception: return 2, None if prior_content == temporary and not same_is_okay: return 1, None return 0, temporary
def drop_keep_clipboard(nnavi500, nexus): if nnavi500 == 1: Key("c-v").execute() else: max_tries = 20 key = str(nnavi500) cb = Clipboard(from_system=True) for i in range(0, max_tries): failure = False try: if key in nexus.clip: Clipboard.set_system_text(nexus.clip[key]) Key("c-v").execute() time.sleep( settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) else: dragonfly.get_engine().speak("slot empty") except Exception: failure = True if not failure: break cb.copy_to_system()
def setUpClass(cls): # Save the current contents of the clipboard. cls.clipboard = Clipboard(from_system=True)