def get_download_folder():
'''获取下载文件夹'''
download_folder = glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
if download_folder is None:
download_folder = os.path.expanduser("~/Music")
return download_folder
def take_picture(self):
"""take_picture - grab a frame from the web cam and save it to
~/Pictures/datestamp.png, where datestamp is the current datestamp.
It's possible to add a prefix to the datestamp by setting the
filename_prefix property.
If play is not called before take_picture,
an error may occur. If take_picture is called immediately after play,
the camera may not be fully initialized, and an error may occur.
Connect to the signal "image-captured" to be alerted when the picture
is saved.
This function has no arguments
returns - a string of the filename used to save the image
"""
stamp = str(datetime.datetime.now())
extension = ".jpg" #".png"
directory = glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
self.filename = directory + self.filename_prefix + stamp + extension
self.camerabin.set_property("filename", self.filename)
self.camerabin.emit("capture-start")
return self.filename
def __choose_dir(self, widget, data=None):
dr = glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
response, directory = quickly.prompts.choose_directory("Photobomb Choose Directory", dr)
if response == gtk.RESPONSE_OK:
self.directory = directory
self.clear_buttons()
self.__get_pics()
def offer_single_export (self, rec, prefs, mult=1, parent=None):
"""Offer to export a single file.
Return the filename if we have in fact exported said file.
"""
default_extension = prefs.get('save_recipe_as','html')
# strip the period if one ended up on our default extension
if default_extension and default_extension[0]=='.':
default_extension = default_extension[1:]
exp_directory = prefs.get('rec_exp_directory',
get_user_special_dir(USER_DIRECTORY_DOCUMENTS)
)
filename,exp_type = de.saveas_file(_('Save recipe as...'),
filename='%s%s%s%s%s'%(exp_directory,
os.path.sep,
rec.title,
os.path.extsep,
default_extension),
filters=self.get_single_filters(),
parent=parent
)
if not filename: return
if not exp_type or not self.can_export_type(exp_type):
de.show_message(label=_('Gourmet cannot export file of type "%s"')%os.path.splitext(filename)[1])
return
return self.do_single_export(rec, filename, exp_type, mult)
def copyFileFromServer(strFileName):
# File resides on server itself
try:
FileToBeCopied = open(strFileName+".txt", "r")
except IOError:
return "File not found."
# File to be "copied" (downloaded) to Downloads folder
try:
# locate Downloads directory on local system
downloadsDir = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
NewFile = open(os.path.join(downloadsDir+"/"+strFileName+".txt"), 'w')
except IOError:
return "Error in downloading file."
# Both files are open, hence begin copying
string = FileToBeCopied.read()
NewFile.write(string)
FileToBeCopied.close()
NewFile.close()
if not FileToBeCopied.closed and not NewFile.closed:
return "Error in downloading file."
else:
return "Download complete."
def offer_multiple_export(self, recs, prefs, parent=None, prog=None):
"""Offer user a chance to export multiple recipes at once.
Return the exporter class capable of doing this and a
dictionary of arguments for the progress dialog.
"""
if len(recs) < 950:
# inelegantly avoid bug that happens when this code runs
# on large numbers of recipes. The good news is that this
# that that will almost only ever happen when we're
# exporting all recipes, which makes this code irrelevant
# anyway.
self.app.rd.include_linked_recipes(recs)
ext = prefs.get("save_recipes_as", "%sxml" % os.path.extsep)
exp_directory = prefs.get("rec_exp_directory", get_user_special_dir(USER_DIRECTORY_DOCUMENTS))
fn, exp_type = de.saveas_file(
_("Export recipes"),
filename="%s%s%s%s" % (exp_directory, os.path.sep, _("recipes"), ext),
parent=parent,
filters=self.get_multiple_filters(),
)
if fn:
prefs["rec_exp_directory"] = os.path.split(fn)[0]
prefs["save_recipes_as"] = os.path.splitext(fn)[1]
instance = self.do_multiple_export(recs, fn, exp_type)
if not instance:
de.show_message(
okay=gtk.STOCK_CLOSE,
cancel=False,
label=_('Unable to export: unknown filetype "%s"' % fn),
sublabel=_("Please make sure to select a filetype from the dropdown menu when saving."),
message_type=gtk.MESSAGE_ERROR,
)
return
return instance
def show(self, filelist):
self.filelist = filelist
self.view.set_model(None)
self.model.clear()
self.add(os.path.expanduser('~'))
self.add(glib.get_user_special_dir(glib.USER_DIRECTORY_DESKTOP))
self.add('trash:///')
self.add('computer:///root.link')
self.add('network:///')
for l in open('/home/bobrov/.gtk-bookmarks'):
self.add(l.strip())
self.view.set_model(self.model)
self.view.set_cursor((0,))
w, h = self.view.size_request()
if h != 0:
self.sw.set_size_request(-1, max(200, min(h + 5, 300)))
self.window.resize(*self.window.size_request())
self.window.set_transient_for(filelist.view.get_toplevel())
self.window.show()
def add_folders_and_bookmarks(self):
self.applet.icons.destroy_all()
# Destroy all current local bookmark monitors
for monitor in self.__monitors:
monitor.cancel()
self.__monitors = []
self.add_folder_icon(_("Home Folder"), "user-home", "file://%s" % user_path)
# Add Desktop
desktop_path = glib.get_user_special_dir(glib.USER_DIRECTORY_DESKTOP)
if desktop_path != user_path:
self.add_folder_icon(glib.filename_display_basename(desktop_path), "user-desktop", "file://%s" % desktop_path)
# Add XDG user special folders
for uri in xdg_user_uris:
self.add_url_name(uri)
# Add bookmarks
if os.path.isfile(bookmarks_file):
with open(bookmarks_file) as f:
for url_name in (i.rstrip().split(" ", 1) for i in f):
if url_name[0] not in xdg_user_uris:
self.add_url_name(*url_name)
def offer_single_export(self, rec, prefs, mult=1, parent=None):
"""Offer to export a single file.
Return the filename if we have in fact exported said file.
"""
default_extension = prefs.get('save_recipe_as', 'html')
# strip the period if one ended up on our default extension
if default_extension and default_extension[0] == '.':
default_extension = default_extension[1:]
exp_directory = prefs.get(
'rec_exp_directory',
get_user_special_dir(USER_DIRECTORY_DOCUMENTS))
filename, exp_type = de.saveas_file(
_('Save recipe as...'),
filename='%s%s%s%s%s' % (exp_directory, os.path.sep, rec.title,
os.path.extsep, default_extension),
filters=self.get_single_filters(),
parent=parent)
if not filename: return
if not exp_type or not self.can_export_type(exp_type):
de.show_message(
label=_('Gourmet cannot export file of type "%s"') %
os.path.splitext(filename)[1])
return
return self.do_single_export(rec, filename, exp_type, mult)
def get_default_download_path():
try:
import glib
except ImportError:
base = os.path.expandvars("$HOME/Downloads")
else:
base = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
return os.path.join(base, "NASA-APOD")
def __init__(self, parent):
super(ImageChooser, self).__init__(
parent, glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES))
self.set_title(_("Select an image..."))
self.add_image_filter()
image = gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_BUTTON)
buttonclear = self.add_button(_("No image"), self.RESPONSE_CLEAR)
buttonclear.set_image(image)
self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
def __init__(self, FILECHOSEN, FILENAME, CONTAINERCHOICE, AUDIOCODECVALUE, VIDEOCODECVALUE):
gobject.GObject.__init__(self)
# create a dictionay taking the Codec/Container values and mapping them with plugin names
# No asfmux atm, hopefully Soc will solve that
# Choose plugin based on Codec Name
audiocaps = codecfinder.codecmap[AUDIOCODECVALUE]
videocaps = codecfinder.codecmap[VIDEOCODECVALUE]
self.AudioEncoderPlugin = codecfinder.get_audio_encoder_element(audiocaps)
self.VideoEncoderPlugin = codecfinder.get_video_encoder_element(videocaps)
# print "Audio encoder plugin is " + self.AudioEncoderPlugin
# print "Video encoder plugin is " + self.VideoEncoderPlugin
# Choose plugin and file suffix based on Container name
containercaps = codecfinder.containermap[CONTAINERCHOICE]
self.ContainerFormatPlugin = codecfinder.get_muxer_element(containercaps)
# print "Container muxer is " + self.ContainerFormatPlugin
self.ContainerFormatSuffix = codecfinder.csuffixmap[CONTAINERCHOICE]
# Remove suffix from inbound filename so we can reuse it together with suffix to create outbound filename
self.FileNameOnly = os.path.splitext(os.path.basename(FILENAME))[0]
self.VideoDirectory = glib.get_user_special_dir(glib.USER_DIRECTORY_VIDEOS)
CheckDir = os.path.isdir(self.VideoDirectory)
if CheckDir == (False):
os.mkdir(self.VideoDirectory)
# elif CheckDir == (True):
# print "Videos directory exist"
# print self.VideoDirectory
# create a variable with a timestamp code
timeget = datetime.datetime.now()
text = timeget.strftime("-%H%M%S-%d%m%Y")
self.timestamp = str(text)
self.pipeline = gst.Pipeline("TranscodingPipeline")
self.pipeline.set_state(gst.STATE_PAUSED)
self.uridecoder = gst.element_factory_make("uridecodebin", "uridecoder")
self.uridecoder.set_property("uri", FILECHOSEN)
# print "File loaded " + FILECHOSEN
self.uridecoder.connect("pad-added", self.OnDynamicPad)
self.pipeline.add(self.uridecoder)
self.containermuxer = gst.element_factory_make(self.ContainerFormatPlugin, "containermuxer")
self.pipeline.add(self.containermuxer)
self.transcodefileoutput = gst.element_factory_make("filesink", "transcodefileoutput")
self.transcodefileoutput.set_property("location", (self.VideoDirectory+self.FileNameOnly+self.timestamp+self.ContainerFormatSuffix))
self.pipeline.add(self.transcodefileoutput)
self.containermuxer.link(self.transcodefileoutput)
self.uridecoder.set_state(gst.STATE_PAUSED)
self.BusMessages = self.BusWatcher()
self.uridecoder.connect("no-more-pads", self.noMorePads) # we need to wait on this one before going further
def __init__ (self,
title,
filename=None,
filters=IMAGE_FILTERS,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
set_filter=True,
buttons=None
):
FileSelectorDialog.__init__(self, title, filename, filters, action, set_filter, buttons)
self.fsd.set_current_folder(get_user_special_dir(USER_DIRECTORY_PICTURES))
def set_download_folder():
downloads_dir = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
if downloads_dir:
# Add any custom folder
new_path = os.path.join(downloads_dir, CUSTOM_FOLDER)
if SHOW_DEBUG:
print "Using automatically detected path:", new_path
else:
new_path = DOWNLOAD_PATH
if SHOW_DEBUG:
print "Could not determine download folder with GLib. Using default."
return new_path
def set_download_folder():
downloads_dir = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
if downloads_dir:
# Add any custom folder
new_path = os.path.join(downloads_dir, CUSTOM_FOLDER)
if SHOW_DEBUG:
print "Using automatically detected path:", new_path
else:
new_path = DOWNLOAD_PATH
if SHOW_DEBUG:
print "Could not determine download folder with GLib. Using default."
return new_path
def get_old_download_dir():
if is_windows:
directory = os.path.join(get_user_home(), "Downloads")
if os.path.isdir(directory):
return directory
# Fallback directory: My documents\Downloads
mydocs = win32.get_my_documents() # My Documents
return os.path.join(mydocs, "Downloads")
else:
if GLib: # GLib should be dependency for POSIX systems
return GLib.get_user_special_dir(GLib.USER_DIRECTORY_DOWNLOAD)
return os.path.join(get_user_home(), "Downloads")
def get_old_download_dir():
if is_windows:
directory = os.path.join(get_user_home(), "Downloads")
if os.path.isdir(directory):
return directory
# Fallback directory: My documents\Downloads
mydocs = win32.get_my_documents() # My Documents
return os.path.join(mydocs, "Downloads")
else:
if GLib: # GLib should be dependency for POSIX systems
return GLib.get_user_special_dir(GLib.USER_DIRECTORY_DOWNLOAD)
return os.path.join(get_user_home(), "Downloads")
def __init__ (self,
title,
filename=None,
filters=IMAGE_FILTERS,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
set_filter=True,
buttons=None
):
FileSelectorDialog.__init__(self, title, filename, filters, action, set_filter, buttons)
pictures_dir = get_user_special_dir(USER_DIRECTORY_PICTURES)
if not pictures_dir == None:
self.fsd.set_current_folder(pictures_dir)
def download_link(self, push):
pushes = self.pb.get_pushes(self.last_push)[1]
if (len(pushes) != 0):
last_push = pushes[len(pushes)-2]
if last_push.get("url"):
url = last_push.get("url")
filename = self.get_filename_from_url(url)
downloads_dir = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
unique_filename = self.get_unique_filename(filename, downloads_dir)
unique_filename_full_path = downloads_dir+"/"+unique_filename
urllib.urlretrieve (url, unique_filename_full_path)
print "URL: %s Downloaded: %s" % (url, unique_filename_full_path)
self.last_push = max(self.last_push, last_push.get("created"))
def __init__(self):
gobject.GObject.__init__(self)
if sys.platform == 'win32':
self.config_dir = os.path.join(os.getenv('APPDATA').decode('mbcs'), 'Reinteract')
else:
self.config_dir = os.path.expanduser(u"~/.reinteract")
try:
# Added in pygobject-2.18
documents_dir = glib.get_user_special_dir(glib.USER_DIRECTORY_DOCUMENTS).decode("UTF-8")
except AttributeError, e:
# In a shocking example of cross-platform convergence, ~/Documents
# is the documents directory on OS X, Windows, and Linux, except
# when localized
documents_dir = os.path.expanduser(u"~/Documents")
def offer_multiple_export(self, recs, prefs, parent=None, prog=None):
"""Offer user a chance to export multiple recipes at once.
Return the exporter class capable of doing this and a
dictionary of arguments for the progress dialog.
"""
if len(recs) < 950:
# inelegantly avoid bug that happens when this code runs
# on large numbers of recipes. The good news is that this
# that that will almost only ever happen when we're
# exporting all recipes, which makes this code irrelevant
# anyway.
self.app.rd.include_linked_recipes(recs)
ext = prefs.get('save_recipes_as', '%sxml' % os.path.extsep)
exp_directory = prefs.get(
'rec_exp_directory',
get_user_special_dir(USER_DIRECTORY_DOCUMENTS))
fn, exp_type = de.saveas_file(
_("Export recipes"),
filename="%s%s%s%s" %
(exp_directory, os.path.sep, _('recipes'), ext),
parent=parent,
filters=self.get_multiple_filters())
if fn:
prefs['rec_exp_directory'] = os.path.split(fn)[0]
prefs['save_recipes_as'] = os.path.splitext(fn)[1]
instance = self.do_multiple_export(recs, fn, exp_type)
if not instance:
de.show_message(
okay=gtk.STOCK_CLOSE,
cancel=False,
label=_('Unable to export: unknown filetype "%s"' % fn),
sublabel=
_('Please make sure to select a filetype from the dropdown menu when saving.'
),
message_type=gtk.MESSAGE_ERROR,
)
return
import gourmet.GourmetRecipeManager
main_app = gourmet.GourmetRecipeManager.get_application()
print 'Connect', instance, 'to show dialog when done'
instance.connect(
'completed',
lambda *args: main_app.offer_url('Export complete!',
'Recipes exported to %s' % fn,
url='file:///%s' % fn))
return instance
def offer_multiple_export (self, recs, prefs, parent=None, prog=None):
"""Offer user a chance to export multiple recipes at once.
Return the exporter class capable of doing this and a
dictionary of arguments for the progress dialog.
"""
if len(recs) < 950:
# inelegantly avoid bug that happens when this code runs
# on large numbers of recipes. The good news is that this
# that that will almost only ever happen when we're
# exporting all recipes, which makes this code irrelevant
# anyway.
self.app.rd.include_linked_recipes(recs)
ext = prefs.get('save_recipes_as','%sxml'%os.path.extsep)
exp_directory = prefs.get('rec_exp_directory',
get_user_special_dir(USER_DIRECTORY_DOCUMENTS)
)
fn,exp_type=de.saveas_file(_("Export recipes"),
filename="%s%s%s%s"%(exp_directory,
os.path.sep,
_('recipes'),
ext),
parent=parent,
filters=self.get_multiple_filters())
if fn:
prefs['rec_exp_directory']=os.path.split(fn)[0]
prefs['save_recipes_as']=os.path.splitext(fn)[1]
instance = self.do_multiple_export(recs, fn, exp_type)
if not instance:
de.show_message(
okay=gtk.STOCK_CLOSE,
cancel=False,
label=_('Unable to export: unknown filetype "%s"'%fn),
sublabel=_('Please make sure to select a filetype from the dropdown menu when saving.'),
message_type=gtk.MESSAGE_ERROR,
)
return
import gourmet.GourmetRecipeManager
main_app = gourmet.GourmetRecipeManager.get_application()
print 'Connect',instance,'to show dialog when done'
instance.connect('completed',
lambda *args: main_app.offer_url('Export complete!',
'Recipes exported to %s'%fn,
url='file:///%s'%fn))
return instance
def __init__(self):
gobject.GObject.__init__(self)
if sys.platform == 'win32':
self.config_dir = os.path.join(
os.getenv('APPDATA').decode('mbcs'), 'Reinteract')
else:
self.config_dir = os.path.expanduser(u"~/.reinteract")
try:
# Added in pygobject-2.18
documents_dir = glib.get_user_special_dir(
glib.USER_DIRECTORY_DOCUMENTS).decode("UTF-8")
except AttributeError, e:
# In a shocking example of cross-platform convergence, ~/Documents
# is the documents directory on OS X, Windows, and Linux, except
# when localized
documents_dir = os.path.expanduser(u"~/Documents")
def download_link(self, push):
pushes = self.pb.get_pushes(self.last_push)[1]
if (len(pushes) != 0):
last_push = pushes[len(pushes) - 2]
if last_push.get("url"):
url = last_push.get("url")
filename = self.get_filename_from_url(url)
downloads_dir = glib.get_user_special_dir(
glib.USER_DIRECTORY_DOWNLOAD)
unique_filename = self.get_unique_filename(
filename, downloads_dir)
unique_filename_full_path = downloads_dir + "/" + unique_filename
urllib.urlretrieve(url, unique_filename_full_path)
print "URL: %s Downloaded: %s" % (url,
unique_filename_full_path)
self.last_push = max(self.last_push, last_push.get("created"))
def get_download_dir():
"Return the path to the user's default downloads directory"
if is_windows:
# WinVista Win7 and so on:
# Win32 API does not provides IDs for its new
# SHGetKnownFolderPath, but it seems the folder name is
# locale unaware (at least in Win7).
directory = os.path.join(get_user_home(), "Downloads")
if os.path.isdir(directory):
return directory
# Fallback directory: My documents\Downloads
mydocs = win32.get_my_documents() # My Documents
return mydocs
else:
if GLib: # GLib should be dependency for POSIX systems
ddir = GLib.get_user_special_dir(GLib.USER_DIRECTORY_DOWNLOAD)
if ddir:
return ddir
return get_user_home()
def get_download_dir():
"Return the path to the user's default downloads directory"
if is_windows:
# WinVista Win7 and so on:
# Win32 API does not provides IDs for its new
# SHGetKnownFolderPath, but it seems the folder name is
# locale unaware (at least in Win7).
directory = os.path.join(get_user_home(), "Downloads")
if os.path.isdir(directory):
return directory
# Fallback directory: My documents\Downloads
mydocs = win32.get_my_documents() # My Documents
return mydocs
else:
if GLib: # GLib should be dependency for POSIX systems
ddir = GLib.get_user_special_dir(GLib.USER_DIRECTORY_DOWNLOAD)
if ddir:
return ddir
return get_user_home()
def set_album_art(self, button):
tburl = self.webview.get_main_frame().get_title()
if not tburl:
return
print "Url: " + tburl
filep = tburl.split('/')
filepath = filep[len(filep) - 1]
(filen, filextn) = os.path.splitext(filepath)
request = urllib2.Request(tburl)
opener = urllib2.build_opener()
image = None
try:
image = opener.open(request).read()
except:
print "Failed to download image"
save_filename = self.current_artist + " - " + self.current_album + ".jpg"
if (self.mode == self.MODE_PICTURES):
covers_folder = glib.get_user_special_dir(
glib.USER_DIRECTORY_PICTURES)
filename = covers_folder + "/" + save_filename
if (self.mode == self.MODE_RHYTHM):
covers_folder = os.environ['HOME'] + "/.cache/rhythmbox/covers/"
filename = covers_folder + save_filename
if (os.path.isdir(covers_folder) == False):
os.mkdir(covers_folder)
if (self.mode == self.MODE_FOLDER):
location_path_improper = urllib2.url2pathname(
self.current_location)
location_path_arr = location_path_improper.split("//")
location_path = location_path_arr[1]
filename = location_path.rsplit("/",
1)[0] + "/cover" #+ save_filename
output = open(filename, 'w')
output.write(image)
output.close()
def set_album_art(self, button) :
tburl = self.webview.get_main_frame().get_title()
if not tburl:
return
print "Url: " + tburl
filep = tburl.split('/')
filepath = filep[len(filep)-1]
(filen, filextn) = os.path.splitext(filepath)
request = urllib2.Request(tburl)
opener = urllib2.build_opener()
image = None
try:
image = opener.open(request).read()
except:
print "Failed to download image"
save_filename=self.current_artist + " - " + self.current_album + ".jpg"
if(self.mode == self.MODE_PICTURES):
covers_folder = glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
filename = covers_folder + "/" + save_filename
if(self.mode == self.MODE_RHYTHM):
covers_folder=os.environ['HOME']+"/.cache/rhythmbox/covers/"
filename = covers_folder + save_filename
if (os.path.isdir(covers_folder) == False):
os.mkdir(covers_folder)
if(self.mode == self.MODE_FOLDER):
location_path_improper = urllib2.url2pathname(self.current_location)
location_path_arr = location_path_improper.split("//")
location_path = location_path_arr[1]
filename = location_path.rsplit("/",1)[0] + "/cover" #+ save_filename
output = open(filename, 'w')
output.write(image)
output.close()
def get_default_download_dir(self):
USER_DIRECTORY_DOWNLOAD = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
if USER_DIRECTORY_DOWNLOAD == None:
USER_DIRECTORY_DOWNLOAD = "~/Downloads"
print _("USER_DIRECTORY_DOWNLOAD variable not found, Defaults to ~/Downloads")
return USER_DIRECTORY_DOWNLOAD
def get_images_dir():
return glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
# Get BingXML file which contains the URL of the Bing Photo of the day
# idx = Number days previous the present day. 0 means current day, 1 means yesterday, etc
# n = Number of images predious the day given by idx
# mkt denotes your location. e.g. en-US means United States. Put in your country code
BingXML_URL = "http://www.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1&mkt=en-GB"
page = urllib2.urlopen(BingXML_URL)
BingXML = BeautifulSoup(page, "lxml")
# For extracting complete URL of the image
Images = BingXML.find_all('image')
ImageURL = "https://www.bing.com" + Images[0].urlbase.text + '_1920x1080.jpg'
ImageName = Images[0].startdate.text+".jpg"
# All the images will be saved in '/home/[user]/[Pictures accordind user language]/BingWallpapers/'
import glib
ruta = glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
path = ruta + '/BingWallpapers/'
if not os.path.exists(path):
os.makedirs(path)
os.chdir(path)
if not os.path.isfile(ImageName):
urllib.urlretrieve(ImageURL, ImageName)
#gsettings_path = os.system('which gsettings')
#if not os.system("/usr/bin/gsettings set org.gnome.desktop.background picture-uri file:" + path + ImageName ):
if not os.system("xfconf-query -c xfce4-desktop -p /backdrop/screen0/monitor0/workspace0/last-image -s " + path + ImageName ):
os.system('notify-send "'+'Bing Wallpaper updated successfully'+'" "'+ Images[0].copyright.text.encode('utf-8') +'"')
os._exit(1)
else:
os.system('notify-send "'+'Bing Wallpaper unchanged'+'" "'+ Images[0].copyright.text.encode('utf-8') + ' Wallpaper already exists in wallpaper directory!' +'"')
os._exit(1)
def initializeBitmaps(self):
try:
self.path = glib.get_user_special_dir(
glib.USER_DIRECTORY_MUSIC) + "/audiobooks/"
files = os.listdir(self.path)
files.remove('fake_cover.png')
files.sort(
key=lambda f: os.path.getmtime(os.path.join(self.path, f)))
self.existingLogos, self.existingMedia = [], []
for item in files:
fileExtension = item[item.rfind('.') + 1:]
if fileExtension == 'png' or fileExtension == 'jpg' or fileExtension == 'jpeg':
self.existingLogos.append(item)
elif fileExtension == 'mp3':
self.existingMedia.append(item)
self.existingLogos = sorted(
self.existingLogos,
key=lambda name: int(name.split('_', 2)[0]))
self.existingMedia = sorted(
self.existingMedia,
key=lambda name: int(name.split('_', 2)[0]))
if len(self.existingMedia) > 0:
self.numberOfPanels = 1 + (len(self.existingMedia) - 1) / (
(self.numberOfRows[0] - 1) * self.numberOfColumns[0])
else:
self.numberOfPanels = 1
self.newHeight = 0.9 * self.winHeight / self.numberOfRows[0]
self.panels = {}
for number in range(self.numberOfPanels):
logoNames = self.existingLogos[number *
(self.numberOfRows[0] - 1) *
self.numberOfColumns[0]:
(number + 1) *
(self.numberOfRows[0] - 1) *
self.numberOfColumns[0]]
logoPaths = [self.path + name for name in logoNames]
logos = [
wx.ImageFromStream(open(logo, "rb")) for logo in logoPaths
]
logos = [
logo.Rescale(
logo.GetSize()[0] *
(self.newHeight / float(logo.GetSize()[1])),
self.newHeight, wx.IMAGE_QUALITY_HIGH)
for logo in logos
]
logoBitmaps = [wx.BitmapFromImage(logo) for logo in logos]
self.panels[number + 1] = [logoNames, logoBitmaps]
except OSError:
self.panels = {1: [[], []]}
self.numberOfPanels = 1
print "Błąd w strukturze plików."
self.functionButtonPath = [
wx.BitmapFromImage(
wx.ImageFromStream(
open(self.pathToAP + 'icons/volume down.png', 'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(
open(self.pathToAP + 'icons/volume up.png', 'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(open(self.pathToAP + 'icons/show.png',
'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(
open(self.pathToAP + 'icons/delete.png', 'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(open(self.pathToAP + 'icons/back.png',
'rb')))
]
self.functionButtonName = [
'volume_down', 'volume_up', 'show', 'delete', 'back'
]
if self.numberOfPanels == 1:
self.flag = 'row'
else:
self.flag = 'panel'
import urllib
import urlparse
import glib
from mopidy import compat, exceptions
from mopidy.compat import queue
from mopidy.utils import encoding
logger = logging.getLogger(__name__)
XDG_DIRS = {
'XDG_CACHE_DIR': glib.get_user_cache_dir(),
'XDG_CONFIG_DIR': glib.get_user_config_dir(),
'XDG_DATA_DIR': glib.get_user_data_dir(),
'XDG_MUSIC_DIR': glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC),
}
# XDG_MUSIC_DIR can be none, so filter out any bad data.
XDG_DIRS = dict((k, v) for k, v in XDG_DIRS.items() if v is not None)
def get_or_create_dir(dir_path):
if not isinstance(dir_path, bytes):
raise ValueError('Path is not a bytestring.')
dir_path = expand_path(dir_path)
if os.path.isfile(dir_path):
raise OSError('A file with the same name as the desired dir, '
'"%s", already exists.' % dir_path)
elif not os.path.isdir(dir_path):
logger.info('Creating dir %s', dir_path)
tmpdict['saving.scrap_prefix'] = dummyobj['save_scrap_prefix']
tmpdict['input.device_mode'] = dummyobj['input_devices_mode']
tmpdict['input.global_pressure_mapping'] = dummyobj['global_pressure_mapping']
return tmpdict
def get_json_config():
settingspath = join(self.confpath, 'settings.json')
jsonstr = open(settingspath).read()
try:
return helpers.json_loads(jsonstr)
except Exception, e:
print "settings.json: %s" % (str(e),)
print "warning: failed to load settings.json, using defaults"
return {}
if sys.platform == 'win32':
import glib
scrappre = join(glib.get_user_special_dir(glib.USER_DIRECTORY_DOCUMENTS).decode('utf-8'),'MyPaint','scrap')
else:
scrappre = '~/MyPaint/scrap'
DEFAULT_CONFIG = {
'saving.scrap_prefix': scrappre,
'input.device_mode': 'screen',
'input.global_pressure_mapping': [(0.0, 1.0), (1.0, 0.0)],
'view.default_zoom': 1.0,
'view.high_quality_zoom': True,
'ui.hide_menubar_in_fullscreen': True,
'ui.hide_toolbar_in_fullscreen': True,
'ui.hide_subwindows_in_fullscreen': True,
'ui.parts': dict(main_toolbar=True, menubar=False),
'ui.feedback.scale': True,
'ui.feedback.last_pos': False,
'ui.toolbar_items': dict(
def _get_tmpl_dir(self): tmpl_dir = glib.get_user_special_dir(glib.USER_DIRECTORY_TEMPLATES) if not tmpl_dir: tmpl_dir = os.path.expanduser(DEFAULT_TMPL_DIR) return tmpl_dir
def copy_to_desktop(source, confirm_dialog_factory):
basename = os.path.basename(source)
desktop = glib.get_user_special_dir(glib.USER_DIRECTORY_DESKTOP)
dest = desktop + "/" + basename
restore_to(source, dest, confirm_dialog_factory)
def find_pictures_dir():
"""find_pictures_dir() -> gio.File
Returns the user's pictures folder.
"""
return gio.File(path=glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES))
def get_home_video():
return glib.get_user_special_dir(glib.USER_DIRECTORY_VIDEOS)
class Application (object):
"""Main application singleton.
This class serves as a global container for everything that needs
to be shared in the GUI. Its constructor is the last part of the
initialization, called by main.py or by the testing scripts.
Access via `gui.application.get_app()`.
"""
#: Singleton instance
_INSTANCE = None
def __init__(self, filenames, app_datapath, app_extradatapath,
user_datapath, user_confpath, version, fullscreen=False):
"""Construct, but do not run.
:params filenames: The list of files to load.
Note: only the first is used.
:param app_datapath: App-specific read-only data area.
Path used for UI definition XML, and the default sets of backgrounds,
palettes, and brush defintions. Often $PREFIX/share/.
:param app_extradatapath: Extra search path for themeable UI icons.
This will be used in addition to $XDG_DATA_DIRS for the purposes of
icon lookup. Normally it's $PREFIX/share, to support unusual
installations outside the usual locations. It should contain an
icons/ subdirectory.
:param user_datapath: Location of the user's app-specific data.
For MyPaint, this means the user's brushes, backgrounds, and
scratchpads. Commonly $XDG_DATA_HOME/mypaint, i.e.
~/.local/share/mypaint
:param user_confpath: Location of the user's app-specific config area.
This is where MyPaint will save user preferences data and the
keyboard accelerator map. Commonly $XDG_CONFIG_HOME/mypaint, i.e.
~/.config/mypaint
:param version: Version string for the about dialog.
:param fullscreen: Go fullscreen after starting.
"""
assert Application._INSTANCE is None
super(Application, self).__init__()
Application._INSTANCE = self
self.user_confpath = user_confpath #: User configs (see __init__)
self.user_datapath = user_datapath #: User data (see __init__)
self.datapath = app_datapath
self.version = version #: version string for the app.
# create config directory, and subdirs where the user might drop files
for basedir in [self.user_confpath, self.user_datapath]:
if not os.path.isdir(basedir):
os.mkdir(basedir)
logger.info('Created basedir %r', basedir)
for datasubdir in ['backgrounds', 'brushes', 'scratchpads']:
datadir = os.path.join(self.user_datapath, datasubdir)
if not os.path.isdir(datadir):
os.mkdir(datadir)
logger.info('Created data subdir %r', datadir)
# Default location for our icons. The user's theme can override these.
icon_theme = Gtk.IconTheme.get_default()
icon_theme.append_search_path(join(app_extradatapath, "icons"))
# Icon sanity check
if not icon_theme.has_icon('mypaint') \
or not icon_theme.has_icon('mypaint-tool-brush'):
logger.error('Error: Where have my icons gone?')
logger.error('Icon search path: %r', icon_theme.get_search_path())
logger.error("Mypaint can't run sensibly without its icons; "
"please check your installation. See "
"https://gna.org/bugs/?18460 for possible solutions")
sys.exit(1)
Gtk.Window.set_default_icon_name('mypaint')
# Core actions and menu structure
resources_xml = join(self.datapath, "gui", "resources.xml")
self.builder = Gtk.Builder()
self.builder.set_translation_domain("mypaint")
self.builder.add_from_file(resources_xml)
self.ui_manager = self.builder.get_object("app_ui_manager")
signal_callback_objs = []
Gdk.set_program_class('MyPaint')
self.pixmaps = PixbufDirectory(join(self.datapath, 'pixmaps'))
self.cursor_color_picker = Gdk.Cursor.new_from_pixbuf(
Gdk.Display.get_default(),
self.pixmaps.cursor_color_picker,
1, 30
)
self.cursors = CursorCache(self)
# unmanaged main brush; always the same instance (we can attach settings_observers)
# this brush is where temporary changes (color, size...) happen
self.brush = brush.BrushInfo()
self.brush.load_defaults()
# Global pressure mapping function, ignored unless set
self.pressure_mapping = None
self.preferences = {}
self.load_settings()
# Keyboard manager
self.kbm = keyboard.KeyboardManager(self)
# File I/O
self.filehandler = filehandling.FileHandler(self)
# Load the main interface
mypaint_main_xml = join(self.datapath, "gui", "mypaint.glade")
self.builder.add_from_file(mypaint_main_xml)
# Main drawing window
self.drawWindow = self.builder.get_object("drawwindow")
signal_callback_objs.append(self.drawWindow)
# Workspace widget. Manages layout of toolwindows, and autohide in
# fullscreen.
workspace = self.builder.get_object("app_workspace")
workspace.build_from_layout(self.preferences["workspace.layout"])
workspace.floating_window_created += self._floating_window_created_cb
fs_autohide_action = self.builder.get_object("FullscreenAutohide")
fs_autohide_action.set_active(workspace.autohide_enabled)
self.workspace = workspace
# Working document: viewer widget
app_canvas = self.builder.get_object("app_canvas")
# Working document: model and controller
model = lib.document.Document(self.brush)
self.doc = document.Document(self, app_canvas, model)
app_canvas.set_model(model)
signal_callback_objs.append(self.doc)
signal_callback_objs.append(self.doc.modes)
self.scratchpad_filename = ""
scratchpad_model = lib.document.Document(self.brush, painting_only=True)
scratchpad_tdw = tileddrawwidget.TiledDrawWidget()
scratchpad_tdw.set_model(scratchpad_model)
self.scratchpad_doc = document.Document(self, scratchpad_tdw,
scratchpad_model,
leader=self.doc)
self.brushmanager = brushmanager.BrushManager(
join(app_datapath, 'brushes'),
join(user_datapath, 'brushes'),
self)
signal_callback_objs.append(self.filehandler)
self.brushmodifier = brushmodifier.BrushModifier(self)
signal_callback_objs.append(self.brushmodifier)
self.line_mode_settings = linemode.LineModeSettings(self)
# Button press mapping
self.button_mapping = ButtonMapping()
# Monitors changes of input device & saves device-specific brushes
self.device_monitor = DeviceUseMonitor(self)
if not self.preferences.get("scratchpad.last_opened_scratchpad", None):
self.preferences["scratchpad.last_opened_scratchpad"] = self.filehandler.get_scratchpad_autosave()
self.scratchpad_filename = self.preferences["scratchpad.last_opened_scratchpad"]
self.brush_color_manager = BrushColorManager(self)
self.brush_color_manager.set_picker_cursor(self.cursor_color_picker)
self.brush_color_manager.set_data_path(self.datapath)
#: Mapping of setting cname to a GtkAdjustment which controls the base
#: value of that setting for the app's current brush.
self.brush_adjustment = {}
self.init_brush_adjustments()
# Connect signals defined in mypaint.xml
callback_finder = CallbackFinder(signal_callback_objs)
self.builder.connect_signals(callback_finder)
self.kbm.start_listening()
self.filehandler.doc = self.doc
self.filehandler.filename = None
Gtk.AccelMap.load(join(self.user_confpath, 'accelmap.conf'))
# Load the default background image if one exists
layer_stack = self.doc.model.layer_stack
inited_background = False
for datapath in [self.user_datapath, self.datapath]:
bg_path = join(datapath, backgroundwindow.BACKGROUNDS_SUBDIR,
backgroundwindow.DEFAULT_BACKGROUND)
if not os.path.exists(bg_path):
continue
bg, errors = backgroundwindow.load_background(bg_path)
if bg:
layer_stack.set_background(bg, make_default=True)
inited_background = True
break
else:
logger.warning("Failed to load default background image %r",
bg_path)
if errors:
for error in errors:
logger.warning("warning: %r", error)
# Otherwise, set a fallback background colour which depends on the UI
# brightness and isn't too glaringly odd if the user's theme doesn't
# have dark/light variants.
if not inited_background:
if self.preferences["ui.dark_theme_variant"]:
bg_color = 153, 153, 153
else:
bg_color = 204, 204, 204
layer_stack.set_background(bg_color, make_default=True)
inited_background = True
# Non-dockable subwindows
# Loading is deferred as late as possible
self._subwindow_classes = {
# action-name: action-class
"BackgroundWindow": backgroundwindow.BackgroundWindow,
"BrushEditorWindow": brusheditor.BrushEditorWindow,
"PreferencesWindow": preferenceswindow.PreferencesWindow,
"InputTestWindow": inputtestwindow.InputTestWindow,
"BrushIconEditorWindow": brushiconeditor.BrushIconEditorWindow,
}
self._subwindows = {}
# Show main UI.
self.drawWindow.show_all()
GObject.idle_add(self._at_application_start, filenames, fullscreen)
def _at_application_start(self, filenames, fullscreen):
col = self.brush_color_manager.get_color()
self.brushmanager.select_initial_brush()
self.brush_color_manager.set_color(col)
if filenames:
# Open only the first file, no matter how many has been specified
# If the file does not exist just set it as the file to save to
fn = filenames[0].replace('file:///', '/')
# ^ some filebrowsers do this (should only happen with outdated
# mypaint.desktop)
if not os.path.exists(fn):
self.filehandler.filename = fn
else:
self.filehandler.open_file(fn)
# Load last scratchpad
sp_autosave_key = "scratchpad.last_opened_scratchpad"
autosave_name = self.preferences[sp_autosave_key]
if not autosave_name:
autosave_name = self.filehandler.get_scratchpad_autosave()
self.preferences[sp_autosave_key] = autosave_name
self.scratchpad_filename = autosave_name
if os.path.isfile(autosave_name):
try:
self.filehandler.open_scratchpad(autosave_name)
except AttributeError:
pass
self.apply_settings()
if not self.pressure_devices:
logger.warning('No pressure sensitive devices found.')
self.drawWindow.present()
# Handle fullscreen command line option
if fullscreen:
self.drawWindow.fullscreen_cb()
def save_settings(self):
"""Saves the current settings to persistent storage."""
self.brushmanager.save_brushes_for_devices()
self.brushmanager.save_brush_history()
self.filehandler.save_scratchpad(self.scratchpad_filename)
settingspath = join(self.user_confpath, 'settings.json')
jsonstr = helpers.json_dumps(self.preferences)
f = open(settingspath, 'w')
f.write(jsonstr)
f.close()
def apply_settings(self):
"""Applies the current settings.
"""
self.update_input_mapping()
self.update_input_devices()
self.update_button_mapping()
self.preferences_window.update_ui()
def load_settings(self):
"""Loads the settings from persistent storage.
Uses defaults if not explicitly configured.
"""
def get_json_config():
settingspath = join(self.user_confpath, 'settings.json')
jsonstr = open(settingspath).read()
try:
return helpers.json_loads(jsonstr)
except Exception, e:
logger.warning("settings.json: %s", str(e))
logger.warning("Failed to load settings: using defaults")
return {}
if sys.platform == 'win32':
import glib
scrappre = join(glib.get_user_special_dir(glib.USER_DIRECTORY_DOCUMENTS).decode('utf-8'),'MyPaint','scrap')
else:
scrappre = '~/MyPaint/scrap'
DEFAULT_CONFIG = {
'saving.scrap_prefix': scrappre,
'input.device_mode': 'screen',
'input.global_pressure_mapping': [(0.0, 1.0), (1.0, 0.0)],
'view.default_zoom': 1.0,
'view.high_quality_zoom': True,
'ui.hide_menubar_in_fullscreen': True,
'ui.hide_toolbar_in_fullscreen': True,
'ui.hide_subwindows_in_fullscreen': True,
'ui.parts': dict(main_toolbar=True, menubar=True),
'ui.feedback.scale': False,
'ui.feedback.last_pos': False,
'ui.feedback.symmetry': True,
'ui.toolbar_items': dict(
toolbar1_file=True,
toolbar1_scrap=False,
toolbar1_edit=True,
toolbar1_blendmodes=False,
toolbar1_linemodes=True,
toolbar1_view_modes=True,
toolbar1_view_manips=False,
toolbar1_view_resets=True,
toolbar1_subwindows=True,
),
'ui.toolbar_icon_size': 'large',
'ui.dark_theme_variant': True,
'saving.default_format': 'openraster',
'brushmanager.selected_brush' : None,
'brushmanager.selected_groups' : [],
'frame.color_rgba': (0.12, 0.12, 0.12, 0.92),
'misc.context_restores_color': True,
"scratchpad.last_opened_scratchpad": "",
# Initial main window positions
"workspace.layout": {
"position": dict(x=50, y=32, w=-50, h=-100),
"autohide": True,
},
# Linux defaults.
# Alt is the normal window resizing/moving key these days,
# so provide a Ctrl-based equivalent for all alt actions.
'input.button_mapping': {
# Note that space is treated as a fake Button2
'<Shift>Button1': 'StraightMode',
'<Control>Button1': 'ColorPickMode',
'<Alt>Button1': 'ColorPickMode',
'Button2': 'PanViewMode',
'<Shift>Button2': 'RotateViewMode',
'<Control>Button2': 'ZoomViewMode',
'<Alt>Button2': 'ZoomViewMode',
'<Control><Shift>Button2': 'FrameEditMode',
'<Alt><Shift>Button2': 'FrameEditMode',
'Button3': 'ShowPopupMenu',
},
}
if sys.platform == 'win32':
# The Linux wacom driver inverts the button numbers of the
# pen flip button, because middle-click is the more useful
# action on Linux. However one of the two buttons is often
# accidentally hit with the thumb while painting. We want
# to assign panning to this button by default.
linux_mapping = DEFAULT_CONFIG["input.button_mapping"]
DEFAULT_CONFIG["input.button_mapping"] = {}
for bp, actname in linux_mapping.iteritems():
bp = bp.replace("Button2", "ButtonTMP")
bp = bp.replace("Button3", "Button2")
bp = bp.replace("ButtonTMP", "Button3")
DEFAULT_CONFIG["input.button_mapping"][bp] = actname
self.preferences = DEFAULT_CONFIG.copy()
try:
user_config = get_json_config()
except IOError:
user_config = {}
self.preferences.update(user_config)
if 'ColorPickerPopup' in self.preferences["input.button_mapping"].values():
# old config file; users who never assigned any buttons would
# end up with Ctrl-Click color picker broken after upgrade
self.preferences["input.button_mapping"] = DEFAULT_CONFIG["input.button_mapping"]
def get_home_music():
return glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
# Get BingXML file which contains the URL of the Bing Photo of the day
# idx = Number days previous the present day. 0 means current day, 1 means yesterday, etc
# n = Number of images predious the day given by idx
# mkt denotes your location. e.g. en-US means United States. Put in your country code
BingXML_URL = "http://www.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1&mkt=en-GB"
page = urllib2.urlopen(BingXML_URL)
BingXML = BeautifulSoup(page, "lxml")
# For extracting complete URL of the image
Images = BingXML.find_all('image')
ImageURL = "https://www.bing.com" + Images[0].urlbase.text + '_1920x1080.jpg'
ImageName = Images[0].startdate.text + ".jpg"
# All the images will be saved in '/home/[user]/[Pictures accordind user language]/BingWallpapers/'
import glib
ruta = glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
path = ruta + '/BingWallpapers/'
if not os.path.exists(path):
os.makedirs(path)
os.chdir(path)
if not os.path.isfile(ImageName):
urllib.urlretrieve(ImageURL, ImageName)
#gsettings_path = os.system('which gsettings')
#if not os.system("/usr/bin/gsettings set org.gnome.desktop.background picture-uri file:" + path + ImageName ):
if not os.system(
"xfconf-query -c xfce4-desktop -p /backdrop/screen0/monitor0/workspace0/last-image -s "
+ path + ImageName):
os.system('notify-send "' + 'Bing Wallpaper updated successfully' +
'" "' + Images[0].copyright.text.encode('utf-8') + '"')
os._exit(1)
def get_special_dir(opt): if opt in specialdirs: return glib.get_user_special_dir(specialdirs[opt])
from mopidy import settings, DATA_PATH
from mopidy.backends.base import (Backend, CurrentPlaylistController,
LibraryController, BaseLibraryProvider, PlaybackController,
BasePlaybackProvider, StoredPlaylistsController,
BaseStoredPlaylistsProvider)
from mopidy.models import Playlist, Track, Album
from mopidy.gstreamer import GStreamer
from .translator import parse_m3u, parse_mpd_tag_cache
logger = logging.getLogger(u'mopidy.backends.local')
DEFAULT_PLAYLIST_PATH = os.path.join(DATA_PATH, 'playlists')
DEFAULT_TAG_CACHE_FILE = os.path.join(DATA_PATH, 'tag_cache')
DEFAULT_MUSIC_PATH = glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
if not DEFAULT_MUSIC_PATH or DEFAULT_MUSIC_PATH == os.path.expanduser(u'~'):
DEFAULT_MUSIC_PATH = os.path.expanduser(u'~/music')
class LocalBackend(ThreadingActor, Backend):
"""
A backend for playing music from a local music archive.
**Issues:** https://github.com/mopidy/mopidy/issues?labels=backend-local
**Dependencies:**
- None
def initializeBitmaps(self):
try:
self.path = glib.get_user_special_dir(
glib.USER_DIRECTORY_MUSIC) + "/"
directories = [
directory for directory in os.listdir(self.path)
if os.path.isdir(os.path.join(self.path, directory))
]
if 'audiobooks' in directories:
directories.remove('audiobooks')
#directories.sort( key=lambda directory: os.path.getmtime( os.path.join(self.path, directory) ) )
try:
directories = sorted(directories,
key=lambda x: int(x.split("_")[0]))
except ValueError:
pass
self.existingLogos, self.existingMedia = [], []
for item in directories:
itemPath = self.path + item + "/"
if 'playlist.m3u' in os.listdir(itemPath):
self.existingMedia.append(itemPath + 'playlist.m3u')
self.existingLogos.append([
itemPath + f for f in os.listdir(itemPath)
if f.startswith("cover")
][0])
else:
ositem = item.replace(' ',
'\ ').replace('(', '\(').replace(
')', '\)').replace('&', '\&')
os.system(
'ls -d -1 -I %s/*.mp* -I %s/*.ogg* > %s/playlist.m3u' %
(self.path.replace(' ', '\ ') + ositem,
self.path.replace(' ', '\ ') + ositem,
self.path.replace(' ', '\ ') + ositem))
self.existingMedia.append(itemPath + 'playlist.m3u')
self.existingLogos.append([
itemPath + f for f in os.listdir(itemPath)
if f.startswith("cover")
][0])
self.existingLogos = [
item.decode('utf-8') for item in self.existingLogos
]
self.existingMedia = [
item.decode('utf-8') for item in self.existingMedia
]
if len(self.existingMedia) > 0:
self.numberOfPanels = 1 + (len(self.existingMedia) - 1) / (
(self.numberOfRows[0] - 1) * self.numberOfColumns[0])
else:
self.numberOfPanels = 1
self.newHeight = 0.9 * self.winHeight / self.numberOfRows[0]
self.panels = {}
for number in range(self.numberOfPanels):
logoNames = self.existingLogos[number *
(self.numberOfRows[0] - 1) *
self.numberOfColumns[0]:
(number + 1) *
(self.numberOfRows[0] - 1) *
self.numberOfColumns[0]]
logos = [
wx.ImageFromStream(open(logo, "rb")) for logo in logoNames
]
logos = [
logo.Rescale(
logo.GetSize()[0] *
(self.newHeight / float(logo.GetSize()[1])),
self.newHeight, wx.IMAGE_QUALITY_HIGH)
for logo in logos
]
logoBitmaps = [wx.BitmapFromImage(logo) for logo in logos]
self.panels[number + 1] = [logoNames, logoBitmaps]
except OSError:
self.panels = {1: [[], []]}
self.numberOfPanels = 1
print "Błąd w strukturze plików."
self.functionButtonPath = [
wx.BitmapFromImage(
wx.ImageFromStream(
open(self.pathToAP + 'icons/volume down.png', 'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(
open(self.pathToAP + 'icons/volume up.png', 'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(open(self.pathToAP + 'icons/show.png',
'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(
open(self.pathToAP + 'icons/delete.png', 'rb'))),
wx.BitmapFromImage(
wx.ImageFromStream(open(self.pathToAP + 'icons/back.png',
'rb')))
]
self.functionButtonName = [
'volume_down', 'volume_up', 'show', 'delete', 'back'
]
if self.numberOfPanels == 1:
self.flag = 'row'
else:
self.flag = 'panel'
def create_places_submenu(self, parent_menu):
item = self.append_menu_item(parent_menu, _("Places"), "folder", None)
menu = gtk.Menu()
item.set_submenu(menu)
user_path = os.path.expanduser("~/")
home_item = self.append_menu_item(menu, _("Home Folder"), "user-home", _("Open your personal folder"))
home_item.connect("activate", self.open_folder_cb, "file://%s" % user_path)
# Add Desktop
desktop_path = glib.get_user_special_dir(glib.USER_DIRECTORY_DESKTOP)
if desktop_path != user_path:
label = glib.filename_display_basename(desktop_path)
desktop_item = self.append_menu_item(menu, label, "user-desktop", _("Open the contents of your desktop in a folder"))
desktop_item.connect("activate", self.open_folder_cb, "file://%s" % desktop_path)
""" Bookmarks """
self.places_menu = menu
self.bookmarks_items = []
self.append_bookmarks()
# Monitor bookmarks file for changes
bookmarks_file = os.path.expanduser("~/.gtk-bookmarks")
self.__bookmarks_monitor = gio.File(bookmarks_file).monitor_file() # keep a reference to avoid getting it garbage collected
def bookmarks_changed_cb(monitor, file, other_file, event):
if event == gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
with self.__rebuild_lock:
self.append_bookmarks()
# Refresh menu to re-initialize the widget
self.places_menu.show_all()
self.__bookmarks_monitor.connect("changed", bookmarks_changed_cb)
menu.append(gtk.SeparatorMenuItem())
""" Devices """
added = False
added |= self.append_awn_desktop(menu, "nautilus-computer")
added |= self.append_awn_desktop(menu, "nautilus-cd-burner")
# Set up volumes and mounts monitor
self.__volumes_mounts_monitor = gio.volume_monitor_get()
self.__volumes_index = len(self.places_menu) - len(self.bookmarks_items)
self.volume_items = []
self.append_volumes()
# TODO if added is False and no volumes, then their are two separators
if added:
menu.append(gtk.SeparatorMenuItem())
added = False
added |= self.append_awn_desktop(menu, "network-scheme")
self.__mounts_index = len(self.places_menu) - len(self.volume_items) - len(self.bookmarks_items)
self.mount_items = []
self.append_mounts()
# TODO if added is False and no mounts, then there are two separators
# Connect signals after having initialized volumes and mounts
for signal in ("volume-added", "volume-changed", "volume-removed", "mount-added", "mount-changed", "mount-removed"):
self.__volumes_mounts_monitor.connect(signal, self.refresh_volumes_mounts_cb)
ncs_exists = os.path.exists(commands.getoutput("which nautilus-connect-server"))
if ncs_exists:
connect_item = self.append_menu_item(menu, _("Connect to Server..."), "applications-internet", _("Connect to a remote computer or shared disk"))
connect_item.connect("activate", lambda w: subprocess.Popen("nautilus-connect-server"))
added |= ncs_exists
if added:
menu.append(gtk.SeparatorMenuItem())
self.append_awn_desktop(menu, "mate-search-tool")
""" Recent Documents """
self.create_documents_submenu(menu)
def create_places_submenu(self, parent_menu):
item = self.append_menu_item(parent_menu, _("Places"), "folder", None)
menu = gtk.Menu()
item.set_submenu(menu)
user_path = os.path.expanduser("~/")
home_item = self.append_menu_item(menu, _("Home Folder"), "user-home", _("Open your personal folder"))
home_item.connect("activate", self.open_folder_cb, "file://%s" % user_path)
# Add Desktop
desktop_path = glib.get_user_special_dir(glib.USER_DIRECTORY_DESKTOP)
if desktop_path != user_path:
label = glib.filename_display_basename(desktop_path)
desktop_item = self.append_menu_item(menu, label, "user-desktop", _("Open the contents of your desktop in a folder"))
desktop_item.connect("activate", self.open_folder_cb, "file://%s" % desktop_path)
""" Bookmarks """
self.places_menu = menu
self.bookmarks_items = []
self.append_bookmarks()
# Monitor bookmarks file for changes
bookmarks_file = os.path.expanduser("~/.gtk-bookmarks")
self.__bookmarks_monitor = gio.File(bookmarks_file).monitor_file() # keep a reference to avoid getting it garbage collected
def bookmarks_changed_cb(monitor, file, other_file, event):
if event == gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
with self.__rebuild_lock:
self.append_bookmarks()
# Refresh menu to re-initialize the widget
self.places_menu.show_all()
self.__bookmarks_monitor.connect("changed", bookmarks_changed_cb)
menu.append(gtk.SeparatorMenuItem())
""" Devices """
added = False
added |= self.append_awn_desktop(menu, "nautilus-computer")
added |= self.append_awn_desktop(menu, "nautilus-cd-burner")
# Set up volumes and mounts monitor
self.__volumes_mounts_monitor = gio.volume_monitor_get()
self.__volumes_index = len(self.places_menu) - len(self.bookmarks_items)
self.volume_items = []
self.append_volumes()
# TODO if added is False and no volumes, then their are two separators
if added:
menu.append(gtk.SeparatorMenuItem())
added = False
added |= self.append_awn_desktop(menu, "network-scheme")
self.__mounts_index = len(self.places_menu) - len(self.volume_items) - len(self.bookmarks_items)
self.mount_items = []
self.append_mounts()
# TODO if added is False and no mounts, then there are two separators
# Connect signals after having initialized volumes and mounts
for signal in ("volume-added", "volume-changed", "volume-removed", "mount-added", "mount-changed", "mount-removed"):
self.__volumes_mounts_monitor.connect(signal, self.refresh_volumes_mounts_cb)
ncs_exists = os.path.exists(commands.getoutput("which nautilus-connect-server"))
if ncs_exists:
connect_item = self.append_menu_item(menu, _("Connect to Server..."), "applications-internet", _("Connect to a remote computer or shared disk"))
connect_item.connect("activate", lambda w: subprocess.Popen("nautilus-connect-server"))
added |= ncs_exists
if added:
menu.append(gtk.SeparatorMenuItem())
self.append_awn_desktop(menu, "gnome-search-tool")
""" Recent Documents """
self.create_documents_submenu(menu)
def get_images_dir():
return glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)
def get_home_music():
return glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
def __init__(self):
#Set up i18n
for module in gtk.glade, gettext:
module.bindtextdomain("transmageddon","../../share/locale")
module.textdomain("transmageddon")
#Set the Glade file
self.gladefile = "transmageddon.glade"
gtk.glade.XML.__init__ (self, self.gladefile)
#Define functionality of our button and main window
self.TopWindow = self.get_widget("TopWindow")
self.FileChooser = self.get_widget("FileChooser")
self.videoinformation = self.get_widget("videoinformation")
self.audioinformation = self.get_widget("audioinformation")
self.CodecBox = self.get_widget("CodecBox")
self.presetchoice = self.get_widget("presetchoice")
self.containerchoice = self.get_widget("containerchoice")
self.codec_buttons = dict()
for c in supported_audio_codecs:
self.codec_buttons[c] = self.get_widget(c+"button")
self.codec_buttons[c].connect("clicked",
self.on_audiobutton_pressed, c)
for c in supported_video_codecs:
self.codec_buttons[c] = self.get_widget(c+"button")
self.codec_buttons[c].connect("clicked",
self.on_videobutton_pressed, c)
self.transcodebutton = self.get_widget("transcodebutton")
self.ProgressBar = self.get_widget("ProgressBar")
self.cancelbutton = self.get_widget("cancelbutton")
self.StatusBar = self.get_widget("StatusBar")
self.TopWindow.connect("destroy", gtk.main_quit)
self.signal_autoconnect(self) # Initialize User Interface
# Set the Videos XDG UserDir as the default directory for the filechooser,
# also make sure directory exists
if 'get_user_special_dir' in glib.__dict__:
self.VideoDirectory = glib.get_user_special_dir(glib.USER_DIRECTORY_VIDEOS)
else:
self.VideoDirectory = os.getenv('HOME')
CheckDir = os.path.isdir(self.VideoDirectory)
if CheckDir == (False):
os.mkdir(self.VideoDirectory)
self.FileChooser.set_current_folder(self.VideoDirectory)
# Setting AppIcon
FileExist = os.path.isfile("../../share/pixmaps/transmageddon.png")
if FileExist:
self.TopWindow.set_icon_from_file("../../share/pixmaps/transmageddon.png")
else:
try:
self.TopWindow.set_icon_from_file("transmageddon.png")
except:
print "failed to find appicon"
# default all but top box to insensitive by default
# self.containerchoice.set_sensitive(False)
self.CodecBox.set_sensitive(False)
self.transcodebutton.set_sensitive(False)
self.cancelbutton.set_sensitive(False)
self.presetchoice.set_sensitive(False)
# set default values for various variables
self.AudioCodec = "vorbis"
self.VideoCodec = "theora"
self.ProgressBar.set_text(_("Transcoding Progress"))
self.p_duration = gst.CLOCK_TIME_NONE
self.p_time = gst.FORMAT_TIME
# Populate the Container format combobox
self.lst = supported_containers
for i in self.lst:
self.containerchoice.append_text(i)
# Populate presets combobox
selected = 0
for x, (id, device) in enumerate(sorted(presets.get().items(),
lambda x, y: cmp(x[1].make + x[1].model,
y[1].make + y[1].model))):
iter = self.presetchoice.append_text(str(device))
if id == "computer":
selected = x
self.presetchoice.prepend_text("No Presets")
def set_download_folder():
downloads_dir = glib.get_user_special_dir(glib.USER_DIRECTORY_DOWNLOAD)
# use equivalent to /home/user/Downloads/NASA-APOD
new_path = os.path.join(downloads_dir, "NASA-APOD")
return new_path
class FolderTwoWay(FileDataProvider.FolderTwoWay, AutoSync.AutoSync):
"""
TwoWay dataprovider for synchronizing a folder
"""
_name_ = _("Folder")
_description_ = _("Synchronize folders")
_configurable_ = True
DEFAULT_FOLDER = "file://" + glib.get_user_special_dir(
glib.USER_DIRECTORY_DOCUMENTS)
DEFAULT_GROUP = "Home"
DEFAULT_HIDDEN = False
DEFAULT_COMPARE_IGNORE_MTIME = False
DEFAULT_FOLLOW_SYMLINKS = False
def __init__(self, *args):
FileDataProvider.FolderTwoWay.__init__(
self, self.DEFAULT_FOLDER, self.DEFAULT_GROUP, self.DEFAULT_HIDDEN,
self.DEFAULT_COMPARE_IGNORE_MTIME, self.DEFAULT_FOLLOW_SYMLINKS)
self.update_configuration(
folder=self.DEFAULT_FOLDER,
includeHidden=self.DEFAULT_HIDDEN,
compareIgnoreMtime=self.DEFAULT_COMPARE_IGNORE_MTIME,
followSymlinks=self.DEFAULT_FOLLOW_SYMLINKS,
)
AutoSync.AutoSync.__init__(self)
self._monitor = VfsFile.MultipleFileMonitor()
self._monitor.connect("changed", self._monitor_folder_cb)
self.update_configuration(
folder=(self.DEFAULT_FOLDER, self._set_folder,
lambda: self.folder),
includeHidden=self.DEFAULT_HIDDEN,
compareIgnoreMtime=self.DEFAULT_COMPARE_IGNORE_MTIME,
followSymlinks=self.DEFAULT_FOLLOW_SYMLINKS)
def __del__(self):
self._monitor.cancel()
def _set_folder(self, f):
log.debug("Setting folder: %s" % f)
self.folder = f
self._monitor.add(f, self._monitor.MONITOR_DIRECTORY)
def config_setup(self, config):
config.add_item(
"Select folder",
"filebutton",
order=1,
config_name="folder",
directory=True,
)
config.add_section("Advanced")
config.add_item("Include hidden files",
"check",
config_name="includeHidden")
config.add_item("Ignore file modification times",
'check',
config_name="compareIgnoreMtime")
config.add_item("Follow symbolic links",
'check',
config_name="followSymlinks")
def get_UID(self):
return self.folder
def get_name(self):
return Vfs.uri_get_filename(self.folder)
def _monitor_folder_cb(self, sender, event_uri, event):
"""
Called when a file in the current folder is changed, added or deleted
"""
# supported events = CHANGED, DELETED, CREATED
if event == self._monitor.MONITOR_EVENT_CREATED:
self.handle_added(event_uri)
elif event == self._monitor.MONITOR_EVENT_CHANGED:
self.handle_modified(event_uri)
elif event == self._monitor.MONITOR_EVENT_DELETED:
self.handle_deleted(event_uri)
def load(self, directory = glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES)):
self.directory = directory
self.__get_pics()
def get_special_dir(opt): if opt in specialdirs: return glib.get_user_special_dir(specialdirs[opt])
def find_pictures_dir():
"""find_pictures_dir() -> gio.File
Returns the user's pictures folder.
"""
return gio.File(
path=glib.get_user_special_dir(glib.USER_DIRECTORY_PICTURES))
def get_home_video():
return glib.get_user_special_dir(glib.USER_DIRECTORY_VIDEOS)
import os
import re
# pylint: disable = W0402
import string
# pylint: enable = W0402
import sys
import urllib
import glib
logger = logging.getLogger('mopidy.utils.path')
XDG_CACHE_DIR = glib.get_user_cache_dir().decode('utf-8')
XDG_CONFIG_DIR = glib.get_user_config_dir().decode('utf-8')
XDG_DATA_DIR = glib.get_user_data_dir().decode('utf-8')
XDG_MUSIC_DIR = glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
if XDG_MUSIC_DIR:
XDG_MUSIC_DIR = XDG_MUSIC_DIR.decode('utf-8')
XDG_DIRS = {
'XDG_CACHE_DIR': XDG_CACHE_DIR,
'XDG_CONFIG_DIR': XDG_CONFIG_DIR,
'XDG_DATA_DIR': XDG_DATA_DIR,
'XDG_MUSIC_DIR': XDG_MUSIC_DIR,
}
DATA_PATH = os.path.join(unicode(XDG_DATA_DIR), 'mopidy')
SETTINGS_PATH = os.path.join(unicode(XDG_CONFIG_DIR), 'mopidy')
SETTINGS_FILE = os.path.join(unicode(SETTINGS_PATH), 'settings.py')
def get_or_create_folder(folder):
folder = os.path.expanduser(folder)
