def format_name(self, format):
for attr in dir(win32clipboard):
if attr.startswith("CF_") and getattr(win32clipboard,
attr) == format:
return attr
else:
return win32clipboard.GetClipboardFormatName(format)
def print_all_formats():
"""
Prints all current clipboard formats and their names, for testing purposes only
"""
# Opens the Clipboard
clp.OpenClipboard()
# Enumerates Clipboard Formats
clp_enum = clp.EnumClipboardFormats(0)
# Loops over Format Enumerations
while clp_enum:
try:
# Gets the Format Name
format_name = clp.GetClipboardFormatName(clp_enum)
except clp.error:
format_name = "not defined"
try:
# Gets the Format
format = clp.GetClipboardData(clp_enum)
except clp.error:
format = "not defined"
print format_name
print format
clp_enum = clp.EnumClipboardFormats(clp_enum)
# Closes the Clipboard
clp.CloseClipboard()
def __get_clipboard(self):
self.logger.info('Getting clipboard contents')
list_to_csv = [("COMPUTER_NAME", "TYPE", "DATA")]
r = None
try:
r = Tk() # Using Tk instead because it supports exotic characters
data = r.selection_get(selection='CLIPBOARD')
r.destroy()
list_to_csv.append(
(self.computer_name, 'clipboard', unicode(data)))
except:
if r: # Verify that r exists before calling destroy
r.destroy()
win32clipboard.OpenClipboard()
clip = win32clipboard.EnumClipboardFormats(0)
while clip:
try:
format_name = win32clipboard.GetClipboardFormatName(clip)
except win32api.error:
format_name = "?"
self.logger.info('format ' + unicode(clip) + ' ' +
unicode(format_name))
if clip == 15: # 15 seems to be a list of filenames
filenames = win32clipboard.GetClipboardData(clip)
for filename in filenames:
list_to_csv.append(
(self.computer_name, 'clipboard', filename))
clip = win32clipboard.EnumClipboardFormats(clip)
win32clipboard.CloseClipboard()
return list_to_csv
def csv_clipboard(self):
"""Exports the clipboard contents"""
# TODO : what happens if clipboard contents is a CSV string ?
self.logger.info('Getting clipboard contents')
with open(self.output_dir + '\\' + self.computer_name + '_clipboard.csv', 'wb') as output:
csv_writer = get_csv_writer(output)
write_to_csv(["COMPUTER_NAME", "TYPE", "DATA"], csv_writer)
r = None #initialize the local variable r
try:
r = Tk() # Using Tk instead because it supports exotic characters
data = r.selection_get(selection='CLIPBOARD')
r.destroy()
write_to_csv([self.computer_name, 'clipboard', unicode(data)], csv_writer)
except:
if r != None: # Verify that r exist before calling destroy
r.destroy()
win32clipboard.OpenClipboard()
clip = win32clipboard.EnumClipboardFormats(0)
while clip:
try:
format_name = win32clipboard.GetClipboardFormatName(clip)
except win32api.error:
format_name = "?"
self.logger.info('format ' + unicode(clip) + ' ' + unicode(format_name))
if clip == 15: # 15 seems to be a list of filenames
filenames = win32clipboard.GetClipboardData(clip)
for filename in filenames:
write_to_csv([self.computer_name, 'clipboard', filename], csv_writer)
clip = win32clipboard.EnumClipboardFormats(clip)
win32clipboard.CloseClipboard()
record_sha256_logs(self.output_dir + '\\' + self.computer_name + '_clipboard.csv',
self.output_dir + '\\' + self.computer_name + '_sha256.log')
def getFormatName(cls, fmt): # pylint: disable=invalid-name
"""Convert a format identifier (integer) to a readable name"""
if fmt in cls.FORMATS:
return cls.FORMATS[fmt]
try:
return win32clipboard.GetClipboardFormatName(fmt)
except:
return "???"
def get_clipboard():
winclip.OpenClipboard()
for i in range(0xd0000):
try:
d = winclip.GetClipboardFormatName(i)
#a = winclip.EnumClipboardFormats()
print str(hex(i)) + " : " + str(d)
except Exception as e:
pass
winclip.CloseClipboard()
def GetFormatName(format_id):
"""Get the string name for a format value"""
# standard formats should not be passed to GetClipboardFormatName
if format_id in _standard_formats:
return _standard_formats[format_id]
win32clipboard.OpenClipboard()
format_name = win32clipboard.GetClipboardFormatName(format_id)
win32clipboard.CloseClipboard()
return format_name
def _update_format_names(self, formats):
# Retrieve and store the names of any registered clipboard formats
# in format_names, if necessary.
for format in formats:
if format in self.format_names:
continue
# Registered clipboard formats are identified by values in
# the range 0xC000 through 0xFFFF.
if 0xC000 <= format <= 0xFFFF:
format_name = win32clipboard.GetClipboardFormatName(format)
self.format_names[format] = format_name
def get_clipboard():
win32clipboard.OpenClipboard()
#
if (win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_DIB)):
try:
data = win32clipboard.GetClipboardData(win32clipboard.CF_DIB)
data_format = win32clipboard.GetClipboardFormatName(
win32clipboard.CF_DIB)
except:
data = ""
data_format = ""
else:
try:
data = win32clipboard.GetClipboardData(win32con.CF_UNICODETEXT)
data_format = win32clipboard.GetClipboardFormatName(
win32con.CF_UNICODETEXT)
except:
data = ""
data_format = ""
win32clipboard.CloseClipboard()
return data, data_format
def check_for_file():
"""
Checks if copied object was a file and then tries to get it's path
"""
try:
clp.OpenClipboard()
clip_enum = clp.EnumClipboardFormats(0)
while clip_enum:
try:
format_name = clp.GetClipboardFormatName(clip_enum)
except clp.error:
format_name = "?"
try:
format = clp.GetClipboardData(clip_enum)
except clp.error:
format = "?"
if (format_name == '?'):
print format
if (len(format) > 0):
print "File Source Path: \n", format[0]
# Path of the copied file
path = format[0]
# If path contains .pdf, extract it's metadata
if (path[-4:] == '.pdf'):
fp = open(path, 'rb')
parser = PDFParser(fp)
doc = PDFDocument(parser)
if 'Title' in doc.info[0]:
title = doc.info[0]['Title']
else:
title = "No Title found"
get_crossref_metadata(title, path)
clip_enum = clp.EnumClipboardFormats(clip_enum)
clp.CloseClipboard()
except:
print "error"
def interpretFormatCode(format):
"""
LONGTERM TODO: This is kept around for debugging but can be deleted from
production code.
Given a format code (of the kind returned from the windows clipboard
functions), returns a string describing the meaning of that
format code.
"""
formatCodeDictionary = {
win32con.CF_BITMAP: "Bitmap Handle",
win32con.CF_DIB: "Bitmap info structure and bits",
win32con.CF_DIF: "Software Arts' Data Interchange Format",
win32con.CF_DSPBITMAP: "Private bitmap display format",
win32con.CF_DSPENHMETAFILE: "Private enhanced metafile display format",
win32con.CF_DSPMETAFILEPICT: "Private metafile-picture display format",
win32con.CF_DSPTEXT: "Private text display format",
win32con.CF_ENHMETAFILE: "Handle to enhanced metafile",
win32con.CF_HDROP: "HDROP dropped files",
win32con.CF_LOCALE:
"Handle to locale information associated with text",
win32con.CF_METAFILEPICT: "Handle to metafile picture format",
win32con.CF_OEMTEXT: "OEM Text",
win32con.CF_OWNERDISPLAY: "Clipboard owner display message",
win32con.CF_PALETTE: "Handle to a color palette",
win32con.CF_PENDATA: "Microsoft Pen Computing data",
win32con.CF_RIFF: "RIFF (Audio data)",
win32con.CF_SYLK: "Microsoft Symbolic Link Format",
win32con.CF_TEXT: "Plain Text",
win32con.CF_TIFF: "TIFF (Tagged Image File Format)",
win32con.CF_UNICODETEXT: "Unicode Text",
win32con.CF_WAVE: "Audio data in wav format"
}
# Formats above 0xC000 are dynamically registered by other
# programs; formats below that correspond to named constants.
if format >= 0xC000:
return win32clipboard.GetClipboardFormatName(format)
elif formatCodeDictionary.has_key(format):
return formatCodeDictionary[format]
else:
return "Unknown data format."
def csv_clipboard(self):
''' Exports the clipboard contents '''
# TODO check if it is the same for older windows
self.logger.info('Getting clipboard contents')
with open(
self.output_dir + '\\' + self.computer_name + '_clipboard.csv',
'wb') as output:
csv_writer = get_csv_writer(output)
#output.write('"Computer Name"|"Type"|Data"\n')
try:
r = Tk(
) # Using Tk instead because it supports exotic characters
data = r.selection_get(selection='CLIPBOARD')
r.destroy()
#data = win32clipboard.GetClipboardData().decode('utf_8')
write_to_csv([
self.computer_name, 'String data in clipboard',
unicode(data)
], csv_writer)
except:
r.destroy()
win32clipboard.OpenClipboard()
clip = win32clipboard.EnumClipboardFormats(0)
while clip:
try:
format_name = win32clipboard.GetClipboardFormatName(
clip)
except win32api.error:
format_name = "?"
self.logger.info('format ' + unicode(clip) + ' ' +
unicode(format_name))
if clip == 15: # 15 seems to be a list of filenames
filenames = win32clipboard.GetClipboardData(clip)
for filename in filenames:
write_to_csv([
self.computer_name,
'List of files in clipboard', filename
], csv_writer)
clip = win32clipboard.EnumClipboardFormats(clip)
win32clipboard.CloseClipboard()
def cb_get_file():
import win32clipboard
file_path = None
win32clipboard.OpenClipboard(None)
fmt = 0
while True:
fmt = win32clipboard.EnumClipboardFormats(fmt)
if fmt == 0:
break
if fmt > 0xC000:
fmt_name = win32clipboard.GetClipboardFormatName(fmt)
# print(fmt_name)
if fmt_name == 'FileNameW':
data = win32clipboard.GetClipboardData(fmt)
file_path = data.decode('utf-16').strip('\0x00')
win32clipboard.CloseClipboard()
return file_path
def _printFormatEtcs(self, formatEtcs):
for (format, a, b, c, d) in formatEtcs: #@UnusedVariable
try:
print u'Format:', format, win32clipboard.GetClipboardFormatName(format) #$NON-NLS-1$
except:
print u'Format not found: ', format #$NON-NLS-1$
import win32clipboard as cb import sys hdrop = cb.CF_HDROP cb.OpenClipboard() print(cb.IsClipboardFormatAvailable(hdrop)) cb.CloseClipboard() sys.exit() ######### data = cb.GetClipboardData() format_name = cb.GetClipboardFormatName(data) print(format_name) data = cb.GetClipboardData(hdrop) cb.CloseClipboard()
def format_names(self):
for fmt in self.formats:
yield win32clipboard.GetClipboardFormatName(fmt)
def clipboard_changed():
"""
Gets called everytime the clioboard data is changed. Source extraction always begins here.
:return: Returns in this method are just used to prevent code from continueing. Actually the extracted sources are then "returned" to the clipboard
"""
try:
print "CLIPBOARD CHANGED"
# Gets current window
current_window = win32gui.GetWindowText(win32gui.GetForegroundWindow())
# Gets current app name by window
app_name = get_app_name(win32gui.GetForegroundWindow())
# We don't want to do anything when copying in Word
if app_name == 'WINWORD.EXE':
return
# If application is Acrobat Reader, try to extract PDF metadata
if "AcroRd32.exe" in app_name or "AcroRd64.exe" in app_name:
last_clipboard_content_for_pdf.append(clipboard.text())
# Save window ID (when copying in a PDF and then switching windows quickly, the window ID is false sometimes, so we save the first one)
if (".pdf"
in win32gui.GetWindowText(win32gui.GetForegroundWindow())):
pdf_window_id.append(win32gui.GetForegroundWindow())
# Clipboard dataChanged fires 5 times when copying in a PDF document, so we execute the function after it's fired for the fifth time
if (len(last_clipboard_content_for_pdf) % 5 == 0):
# Get process ID of PDF reader
process_id = win32process.GetWindowThreadProcessId(
pdf_window_id[-1])
# Gets the PDF metadata, then searches Crossref API and puts the data on the clipboard
get_pdf_metadata(current_window, process_id)
return
else:
# If clipboard data has HTML-Format, extract the source
if HTMLClipboard.HasHtml():
# Source URL of copied content
source = HTMLClipboard.GetSource()
print source
if (source != None):
if source != 'about:blank':
# Gets metadata from source URL
get_metadata_from_url(source)
if wikipedia_base_url in source:
# Gets the english Wiki citations and puts them on the clipboard
put_wiki_citation_to_clipboard(source)
return
if wikipedia_base_url_german in source:
# Gets the german Wiki citations and puts them on the clipboard
put_german_wiki_citation_to_clipboard(source)
return
# If clipboard has HTML-Fragment, but the source is 'None', it's an image
if (source == None):
try:
print "is image"
try:
html = ""
clp.OpenClipboard(None)
clp_enum = clp.EnumClipboardFormats(0)
while clp_enum:
try:
format_name = clp.GetClipboardFormatName(
clp_enum)
except clp.error:
format_name = "?"
try:
format = clp.GetClipboardData(clp_enum)
except clp.error:
format = "?"
if (format_name == "HTML Format"):
print format
html = format
break
clp_enum = clp.EnumClipboardFormats(clp_enum)
clp.CloseClipboard()
# Find the image source URL with beautifulsoup
soup = BeautifulSoup(html, "html.parser")
link = soup.find('img')['src']
print link
# Image source URL
source = link
except:
print "could not find source"
return
# Checks if image was from Wikimedia
if "wikimedia" in current_window.lower():
# Gets Wikimedia citations
meta_data = get_wiki_media_metadata(source)
# Puts the extracted citations on the clipboard
clp.OpenClipboard(None)
sources = {}
meta = {}
sources['content'] = "image with citation"
sources['source'] = source
meta['citations'] = meta_data['APA']
print meta_data
clp.SetClipboardData(src_format,
json.dumps(sources))
clp.SetClipboardData(citation_format,
json.dumps(meta))
clp.CloseClipboard()
return
# Checks if copied image was from Getty Images
if "getty" in current_window.lower():
# Gets the image's metadata
meta_data = get_getty_image_metadata(source)
# Puts the extracted metadata on the clipboard
clp.OpenClipboard(None)
sources = {}
meta = {}
sources['content'] = "image with metadata"
sources['source'] = source
meta['citations'] = meta_data
print meta_data
clp.SetClipboardData(src_format,
json.dumps(sources))
clp.SetClipboardData(citation_format,
json.dumps(meta))
clp.CloseClipboard()
return
else:
# If the image is not from Wikimedia or Getty Images, extract it's source URL and put it on the clipboard
try:
clp.OpenClipboard(None)
try:
src = clp.GetClipboardData(src_format)
except:
src = 'none'
# After putting the data on the clipboard, clipboardChanged is called again. In this case we return and do nothing
if "image" in src:
clp.CloseClipboard()
return
else:
# Put the image source on the clipboard
sources = {}
sources['content'] = "image"
sources['source'] = source
clp.OpenClipboard(None)
clp.SetClipboardData(
src_format, json.dumps(sources))
print clp.GetClipboardData(src_format)
clp.CloseClipboard()
return
except:
# If above code fails, try to put the source on the clipboard anyway
sources = {}
sources['content'] = "image"
sources['source'] = source
clp.OpenClipboard(None)
clp.SetClipboardData(src_format,
json.dumps(sources))
print clp.GetClipboardData(src_format)
clp.CloseClipboard()
return
except:
print "image exception"
# If clipboard contains HTML data, but everything above fails, try to put the URL and the content on the clipboard
clp.OpenClipboard(None)
sources = {}
sources['source'] = source
sources['content'] = unicode(clp.GetClipboardData(clp.CF_TEXT),
errors='replace')
clp.SetClipboardData(src_format, json.dumps(sources))
clp.CloseClipboard()
else:
# If clipboard has no HTML-content, check if it's a file
check_for_file()
except:
# Close the clipboard, if there was an exception when trying to extract sources
try:
clp.CloseClipboard()
except:
print "Clipboard was not open"
print "exception"
