def make_menu_javascript(self, query):
""" Creates the javascript function required to generate the menu """
result = '''<table class=MenuBar><tr>'''
submenus = ''
## Find all families:
module_list = Registry.REPORTS.get_families()
Theme.order_families(module_list)
for k in module_list:
items = 0
submenu_text = '\n<table class=PopupMenu id="PopupMenu%s">' % k
## Add the reports in the family:
report_list = Registry.REPORTS.family[k]
for r in report_list:
if r.hidden: continue
submenu_text += "<tr class='MenuItem' onclick='SelectMenuItem(\"f?report=%s&family=%s\")'><td>%s</td></tr>\n" % (
r.name, k, r.name)
items += 1
continue
if items > 0:
result += "\n<td class=MenuBarItem id='MenuBarItem%s' onmouseover='displaySubMenu(\"%s\")'>%s</td>" % (
k, k, k.replace(" ", " "))
submenus += submenu_text + "</table>"
return result + "<td style='width=100%'></td></tr></table>" + submenus
class Page(WebComponent):
def __init__(self, id, cfg=None, helps=[]):
WebComponent.__init__(self, id, cfg)
self.macros = {}
self.helps = helps[:]
self.theme = Theme('default')
self.AddMacroContent('current', id)
self.AddMacroContent('version', VERSION)
def Render(self):
self._add_help_macro()
return self.theme.BuildTemplate(self.macros, self._id)
def AddMacroContent(self, key, value):
self.macros[key] = value
def Read(self, name):
return self.theme.ReadFile(name)
# Help
#
def AddHelp(self, (help_file, comment)):
for h, c in self.helps:
if h == help_file:
return
self.helps.append((help_file, comment))
def __init__(self, corpus, old_theme_words, new_theme_words):
"""Initialize parser"""
print("Initializing themes.")
textified_corpus = Text(word.lower() for word in corpus.words())
print("Finished textifying corpus.")
self._old_theme = Theme.Theme(textified_corpus, old_theme_words)
self._new_theme = Theme.Theme(textified_corpus, new_theme_words)
def render(self, visibility, topMost):
try:
font = self.engine.data.fontDict[Theme.characterCreateOptionFont]
helpFont = self.engine.data.fontDict[Theme.characterCreateHelpFont]
except KeyError:
font = self.engine.data.font
helpFont = self.engine.data.loadingFont
self.engine.view.setOrthogonalProjection(normalize=True)
v = ((1 - visibility)**2)
w, h = self.fullView
try:
if self.background:
wFactor = 640.000 / self.background.width1()
self.engine.drawImage(self.background,
scale=(wFactor, -wFactor),
coord=(w / 2, h / 2))
for i, option in enumerate(self.options):
r, g, b = Theme.characterCreateHelpColor
glColor3f(r, g, b)
cursor = ""
if self.selected == i:
wText, hText = helpFont.getStringSize(
option[1], scale=Theme.characterCreateScale)
helpFont.render(option[1],
(Theme.characterCreateHelpX - (wText / 2),
Theme.characterCreateHelpY - hText),
scale=Theme.characterCreateHelpScale)
r, g, b = Theme.characterCreateSelectColor
glColor3f(r, g, b)
cursor = self.cursor
else:
r, g, b = Theme.characterCreateFontColor
glColor3f(r, g, b)
wText, hText = font.getStringSize(
option[0], scale=Theme.characterCreateScale)
font.render(option[0],
(Theme.characterCreateX, Theme.characterCreateY +
Theme.characterCreateSpace * i),
scale=Theme.characterCreateScale)
if self.active and self.selected == i:
Theme.setSelectedColor(1 - v)
if i == 0 or i > 5:
wText, hText = font.getStringSize(
self.choices[i], scale=Theme.characterCreateScale)
font.render(self.choices[i] + cursor,
(Theme.characterCreateOptionX - wText,
Theme.characterCreateY +
Theme.characterCreateSpace * i),
scale=Theme.characterCreateScale)
else:
wText, hText = font.getStringSize(
self.values[i - 1][self.choices[i]],
scale=Theme.characterCreateScale)
font.render(self.values[i - 1][self.choices[i]],
(Theme.characterCreateOptionX - wText,
Theme.characterCreateY +
Theme.characterCreateSpace * i),
scale=Theme.characterCreateScale)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
v = (1 - visibility)**2
# render the background
t = self.time / 100
w, h, = self.engine.view.geometry[2:4]
r = .5
self.background.transform.reset()
self.background.transform.translate(
v * 2 * w + w / 2 + math.sin(t / 2) * w / 2 * r,
h / 2 + math.cos(t) * h / 2 * r)
self.background.transform.rotate(-t)
self.background.transform.scale(
math.sin(t / 8) + 2,
math.sin(t / 8) + 2)
self.background.draw()
self.engine.view.setOrthogonalProjection(normalize=True)
font = self.engine.data.font
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
wrapText(font, (.1, .05 - v), self.prompt)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
v = (1 - visibility) ** 2
fadeScreen(v)
Theme.setBaseColor(1 - v)
if (self.time % 10) < 5 and visibility > .9:
cursor = "|"
else:
cursor = ""
pos = wrapText(font, (.1, .33 - v), self.prompt)
Theme.setSelectedColor(1 - v)
if self.text is not None:
pos = wrapText(font, (.1, (pos[1] + v) + .08 + v / 4), self.text)
font.render(cursor, pos)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
fadeScreen(v)
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
wrapText(font, (.1, .2 - v), self.prompt)
for n, c in enumerate(Guitar.KEYS):
if self.controls.getState(c):
glColor3f(*self.fretColors[n])
else:
glColor3f(.4, .4, .4)
font.render("#%d" % (n + 1), (.5 - .15 * (2 - n), .4 + v))
if self.controls.getState(Player.ACTION1) or \
self.controls.getState(Player.ACTION2):
Theme.setSelectedColor(1 - v)
else:
glColor3f(.4, .4, .4)
font.render(_("Pick!"), (.45, .5 + v))
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
fadeScreen(v)
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
wrapText(font, (.1, .2 - v), self.prompt)
for n, c in enumerate(Guitar.KEYS):
if self.controls.getState(c):
glColor3f(*self.fretColors[n])
else:
glColor3f(.4, .4, .4)
font.render("#%d" % (n + 1), (.5 - .15 * (2 - n), .4 + v))
if self.controls.getState(Player.ACTION1) or \
self.controls.getState(Player.ACTION2):
Theme.setSelectedColor(1 - v)
else:
glColor3f(.4, .4, .4)
font.render(_("Pick!"), (.45, .5 + v))
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
if not font:
return
if visibility > 0.9:
self.engine.boostBackgroundThreads(True)
else:
self.engine.boostBackgroundThreads(False)
try:
v = (1 - visibility) ** 2
fadeScreen(v)
#This paragraph carries the information of the image to be rendered.
w, h = self.engine.view.geometry[2:4]
self.engine.data.loadingImage.transform.reset()
self.engine.data.loadingImage.transform.translate(w / 2, (1.0 - v * .25) * h / 2)
self.engine.data.loadingImage.transform.scale(1, -1)
self.engine.data.loadingImage.draw(color = (1, 1, 1, visibility))
Theme.setBaseColor(1 - v)
w, h = font.getStringSize(self.text)
x = .5 - w / 2
y = .6 - h / 2 + v * .5
font.render(self.text, (x, y))
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
v = (1 - visibility) ** 2
fadeScreen(v)
Theme.setBaseColor(1 - v)
if (self.time % 10) < 5 and visibility > .9:
cursor = "|"
else:
cursor = ""
pos = wrapText(font, (.1, .33 - v), self.prompt)
Theme.setSelectedColor(1 - v)
if self.text is not None:
pos = wrapText(font, (.1, (pos[1] + v) + .08 + v / 4), self.text)
font.render(cursor, pos)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
if not font:
return
if visibility > 0.9:
self.engine.boostBackgroundThreads(True)
else:
self.engine.boostBackgroundThreads(False)
try:
v = (1 - visibility) ** 2
fadeScreen(v)
w, h = self.engine.view.geometry[2:4]
self.engine.data.loadingImage.transform.reset()
self.engine.data.loadingImage.transform.translate(w / 2, (1.0 - v * .25) * h / 2)
self.engine.data.loadingImage.transform.scale(1, -1)
self.engine.data.loadingImage.draw(color = (1, 1, 1, visibility))
Theme.setBaseColor(1 - v)
w, h = font.getStringSize(self.text)
x = .5 - w / 2
y = .6 - h / 2 + v * .5
font.render(self.text, (x, y))
finally:
self.engine.view.resetProjection()
def make_menu_javascript(self,query):
""" Creates the javascript function required to generate the menu """
result = '''<table class=MenuBar><tr>'''
submenus = ''
## Find all families:
module_list = Registry.REPORTS.get_families()
Theme.order_families(module_list)
for k in module_list:
items = 0
submenu_text = '\n<table class=PopupMenu id="PopupMenu%s">' % k
## Add the reports in the family:
report_list = Registry.REPORTS.family[k]
for r in report_list:
if r.hidden: continue
submenu_text+="<tr class='MenuItem' onclick='SelectMenuItem(\"f?report=%s&family=%s\")'><td>%s</td></tr>\n" % (r.name, k, r.name)
items += 1
continue
if items > 0:
result += "\n<td class=MenuBarItem id='MenuBarItem%s' onmouseover='displaySubMenu(\"%s\")'>%s</td>" % (k,k,k.replace(" "," "))
submenus += submenu_text + "</table>"
return result + "<td style='width=100%'></td></tr></table>" + submenus
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
# render the background
t = self.time / 100
w, h, = self.engine.view.geometry[2:4]
r = .5
if self.spinnyDisabled != True and Theme.spinnyEditorDisabled != True:
self.background.transform.reset()
self.background.transform.translate(v * 2 * w + w / 2 + math.sin(t / 2) * w / 2 * r, h / 2 + math.cos(t) * h / 2 * r)
self.background.transform.rotate(-t)
self.background.transform.scale(math.sin(t / 8) + 2, math.sin(t / 8) + 2)
self.background.draw()
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
wrapText(font, (.1, .05 - v), self.prompt)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
if not self.song:
return
v = 1.0 - ((1 - visibility)**2)
# render the background
t = self.time / 100 + 34
w, h, = self.engine.view.geometry[2:4]
r = .5
if self.spinnyDisabled != True and Theme.spinnyEditorDisabled:
self.background.transform.reset()
self.background.transform.translate(
w / 2 + math.sin(t / 2) * w / 2 * r,
h / 2 + math.cos(t) * h / 2 * r)
self.background.transform.rotate(-t)
self.background.transform.scale(
math.sin(t / 8) + 2,
math.sin(t / 8) + 2)
self.background.draw()
self.camera.target = (2, 0, 5.5)
self.camera.origin = (-2, 9, 5.5)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(60, 4.0 / 3.0, 0.1, 1000)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
self.camera.apply()
self.guitar.render(v, self.song, self.scrollPos, self.controls)
self.engine.view.setOrthogonalProjection(normalize=True)
font = self.engine.data.font
try:
Theme.setSelectedColor()
w, h = font.getStringSize(" ")
if self.song.isPlaying():
status = _("Playing")
else:
status = _("Stopped")
t = "%d.%02d'%03d" % (self.pos / 60000,
(self.pos % 60000) / 1000, self.pos % 1000)
font.render(t, (.05, .05 - h / 2))
font.render(status, (.05, .05 + h / 2))
font.render(unicode(self.song.difficulty[0]),
(.05, .05 + 3 * h / 2))
Theme.setBaseColor()
text = self.song.info.name + (self.modified and "*" or "")
Dialogs.wrapText(font, (.5, .05 - h / 2), text)
finally:
self.engine.view.resetProjection()
def activateMod(engine, modName):
modPath = _getModPath(engine)
m = os.path.join(modPath, modName)
t = os.path.join(m, "theme.ini")
if os.path.isdir(m):
engine.resource.addDataPath(m)
if os.path.isfile(t):
theme = Config.load(t)
Theme.open(theme)
def activateMod(engine, modName):
modPath = _getModPath(engine)
m = os.path.join(modPath, modName)
t = os.path.join(m, "theme.ini")
if os.path.isdir(m):
engine.resource.addDataPath(m)
if os.path.isfile(t):
theme = Config.load(t)
Theme.open(theme)
def __init__(self, id, cfg=None, helps=[]):
WebComponent.__init__(self, id, cfg)
self.macros = {}
self.helps = helps[:]
self.theme = Theme('default')
self.AddMacroContent('current', id)
self.AddMacroContent('version', VERSION)
def setCassetteColor(self):
if self.song.info.cassetteColor:
color = Theme.colorToHex(self.song.info.cassetteColor)
else:
color = ""
color = Dialogs.getText(self.engine, str("Enter cassette color in HTML (#RRGGBB) format."), color)
if color:
try:
self.song.info.setCassetteColor(Theme.hexToColor(color))
self.modified = True
except ValueError:
Dialogs.showMessage(self.engine, str("That isn't a color."))
def setCassetteColor(self):
if self.song.info.cassetteColor:
color = Theme.colorToHex(self.song.info.cassetteColor)
else:
color = ""
color = Dialogs.getText(self.engine, _("Enter cassette color in HTML (#RRGGBB) format."), color)
if color:
try:
self.song.info.setCassetteColor(Theme.hexToColor(color))
self.modified = True
except ValueError:
Dialogs.showMessage(self.engine, _("That isn't a color."))
def debugOut(self, engine):
f = open("debug.txt", "w+")
version = Version.version()
currentDir = os.getcwd()
dataDir = Version.dataPath()
translationDir = dataDir + "/translations"
modsDir = dataDir + "/mods"
f.write("Date = %s\n" % datetime.datetime.now())
f.write("\nVersion = %s\n" % version)
f.write("\nOS = %s\n" % os.name)
f.write("\nCurrent Directory = %s\n" % currentDir)
self.directoryList(f, currentDir)
f.write("\nData Directory = %s\n" % dataDir)
self.directoryList(f, dataDir)
f.write("\nLibrary.zip\n")
zip = zipfile.ZipFile(dataDir + "/library.zip", 'r')
for info in zip.infolist():
fileName = info.filename
fileCSize = info.compress_size
fileSize = info.file_size
fileDate = datetime.datetime(*(info.date_time))
f.write("%s, %s, %s, %s\n" % (fileName, fileCSize, fileSize, fileDate))
f.write("\nTranslation Directory = %s\n" % translationDir)
self.directoryList(f, translationDir)
f.write("\nMods Directory = %s\n" % modsDir)
self.directoryList(f, modsDir)
mods = os.listdir(modsDir)
for mod in mods:
modDir = os.path.join(modsDir, mod)
if os.path.isdir(modDir):
f.write("\nMod Directory = %s\n" % modDir)
self.directoryList(f, modDir)
f.write("\nFretsonfire.ini\n")
engine.config.config.write(f)
f.write("\nTheme.ini\n")
Theme.write(f, engine.config)
f.write("\nStage.ini\n")
stage = Stage.Stage(self, self.engine.resource.fileName("stage.ini"))
stage.config.write(f)
f.close()
def render(self, visibility, topMost):
if not self.song:
return
v = 1.0 - ((1 - visibility) ** 2)
# render the background
t = self.time / 100 + 34
w, h, = self.engine.view.geometry[2:4]
r = .5
if self.spinnyDisabled != True and Theme.spinnyEditorDisabled:
self.background.transform.reset()
self.background.transform.translate(w / 2 + math.sin(t / 2) * w / 2 * r, h / 2 + math.cos(t) * h / 2 * r)
self.background.transform.rotate(-t)
self.background.transform.scale(math.sin(t / 8) + 2, math.sin(t / 8) + 2)
self.background.draw()
self.camera.target = ( 2, 0, 5.5)
self.camera.origin = (-2, 9, 5.5)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(60, 4.0 / 3.0, 0.1, 1000)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
self.camera.apply()
self.guitar.render(v, self.song, self.scrollPos, self.controls)
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
Theme.setSelectedColor()
w, h = font.getStringSize(" ")
if self.song.isPlaying():
status = str("Playing")
else:
status = str("Stopped")
t = "%d.%02d'%03d" % (self.pos / 60000, (self.pos % 60000) / 1000, self.pos % 1000)
font.render(t, (.05, .05 - h / 2))
font.render(status, (.05, .05 + h / 2))
font.render(unicode(self.song.difficulty[0]), (.05, .05 + 3 * h / 2))
Theme.setBaseColor()
text = self.song.info.name + (self.modified and "*" or "")
Dialogs.wrapText(font, (.5, .05 - h / 2), text)
finally:
self.engine.view.resetProjection()
def debugOut(self, engine):
f = open("debug.txt", "w+")
version = Version.version()
currentDir = os.getcwd()
dataDir = Version.dataPath()
translationDir = dataDir + "/translations"
modsDir = dataDir + "/mods"
f.write("Date = %s\n" % datetime.datetime.now())
f.write("\nVersion = %s\n" % version)
f.write("\nOS = %s\n" % os.name)
f.write("\nCurrent Directory = %s\n" % currentDir)
self.directoryList(f, currentDir)
f.write("\nData Directory = %s\n" % dataDir)
self.directoryList(f, dataDir)
f.write("\nLibrary.zip\n")
zip = zipfile.ZipFile(dataDir + "/library.zip", 'r')
for info in zip.infolist():
fileName = info.filename
fileCSize = info.compress_size
fileSize = info.file_size
fileDate = datetime.datetime(*(info.date_time))
f.write("%s, %s, %s, %s\n" % (fileName, fileCSize, fileSize, fileDate))
f.write("\nTranslation Directory = %s\n" % translationDir)
self.directoryList(f, translationDir)
f.write("\nMods Directory = %s\n" % modsDir)
self.directoryList(f, modsDir)
mods = os.listdir(modsDir)
for mod in mods:
modDir = os.path.join(modsDir, mod)
if os.path.isdir(modDir):
f.write("\nMod Directory = %s\n" % modDir)
self.directoryList(f, modDir)
f.write("\nFretsonfire.ini\n")
engine.config.config.write(f)
f.write("\nTheme.ini\n")
Theme.write(f, engine.config)
f.write("\nStage.ini\n")
stage = Stage.Stage(self, self.engine.resource.fileName("stage.ini"))
stage.config.write(f)
f.close()
def initTheme(self):
""" Loads the current theme
"""
self.theme = Theme(self.setting.get('gui_theme_name', 'DarkBlue'),
self.screen)
self.theme.load()
self.images, self.colours, self.fonts = {}, {}, {}
for k, v in self.theme.images.iteritems():
self.images[k] = Tkinter.PhotoImage(
file=os.path.join(self.theme.basepath, v))
self.colours = self.theme.colours
for k, v in self.theme.fonts.iteritems():
self.fonts[k] = tkFont.Font(family=v['family'], size=v['size'])
def initBackground(self):
self.background = pygame.Surface(
(self.config["screenWidth"], self.config["screenHeight"]))
self.background.fill(
Theme.getColor("textInput/backgroundColor", (131, 139, 139)))
self.buttonSurface = pygame.Surface(
(self.buttonWidth, self.buttonHeight))
self.buttonSurface.fill(
Theme.getColor("textInput/buttonColor", (191, 191, 191)))
self.buttonSelectSurface = pygame.Surface(
(self.buttonWidth, self.buttonHeight))
self.buttonSelectSurface.fill(
Theme.getColor("textInput/selectionColor", (255, 255, 255)))
def render(self, visibility, topMost):
if not visibility:
return
self.engine.view.setOrthogonalProjection(normalize=True)
try:
v = (1 - visibility)**2
font = self.engine.data.font
if self.fadeScreen:
Dialogs.fadeScreen(v)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
n = len(self.choices)
x, y = self.pos
w, h = font.getStringSize("_")
for i, choice in enumerate(
self.choices[self.viewOffset:self.viewOffset +
self.viewSize]):
text = choice.getText(i + self.viewOffset == self.currentIndex)
glPushMatrix()
glRotate(v * 45, 0, 0, 1)
# Draw arrows if scrolling is needed to see all items
if i == 0 and self.viewOffset > 0:
Theme.setBaseColor(
(1 - v) * max(.1, 1 - (1.0 / self.viewOffset) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up=(0, -1), s=.015)
glPopMatrix()
elif i == self.viewSize - 1 and self.viewOffset + self.viewSize < n:
Theme.setBaseColor((1 - v) * max(
.1, 1 - (1.0 /
(n - self.viewOffset - self.viewSize)) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up=(0, 1), s=.015)
glPopMatrix()
if i + self.viewOffset == self.currentIndex:
a = (math.sin(self.time) * .15 + .75) * (1 - v * 2)
Theme.setSelectedColor(a)
a *= -.005
glTranslatef(a, a, a)
else:
Theme.setBaseColor(1 - v)
font.render(text, (x - v / 4, y))
v *= 2
y += h
glPopMatrix()
finally:
self.engine.view.resetProjection()
def optionsCallback(self, selection, text):
self.overlay = None
opt = Theme.getConfigOptions()
if (text == "add"):
opt["useSidebar"] = True
self.subComponent = ConfigMenu.ConfigMenu(self.screen, "Add new link",opt, \
self.getEmptyData() ,self.configOptions ,self.addEditCallback)
footer = Footer.Footer([("theme/direction.png", "select")],
[("theme/b_button.png", "back"),
("theme/a_button.png", "change"),
("theme/start_button.png", "save")],
opt["footerFontColor"], opt["footerColor"])
self.subComponent.setFooter(footer)
self.subComponent.setConfigCallback(self.configCallback)
if (text == "edit"):
self.subComponent = ConfigMenu.ConfigMenu(self.screen, "Edit link",opt, \
self.currentSelection ,self.configOptions ,self.addEditCallback)
footer = Footer.Footer([("theme/direction.png", "select")],
[("theme/b_button.png", "back"),
("theme/a_button.png", "change"),
("theme/start_button.png", "save")],
opt["footerFontColor"], opt["footerColor"])
self.subComponent.setFooter(footer)
self.subComponent.setConfigCallback(self.configCallback)
if (text == "remove"):
self.overlay = ConfirmOverlay.ConfirmOverlay(
"really delete?", [("theme/b_button.png", "back"),
("theme/a_button.png", "delete")],
self.deleteCallback)
RenderControl.setDirty()
def openSelection(self):
options = Theme.getSelectionOptions()
options["textColor"] = (55, 55, 55)
options["background"] = self.options["background"]
options["useSidebar"] = False
if ("selectDescription"
in self.entryList[self.currentIndex]["options"]):
options["description"] = self.entryList[
self.currentIndex]["options"]["selectDescription"]
if ("folderIcon" in self.options):
options["folderIcon"] = self.options["folderIcon"]
if ("fileFilter" in self.entryList[self.currentIndex]["options"]):
options["fileFilter"] = self.entryList[
self.currentIndex]["options"]["fileFilter"]
if ("selectionPath" in self.entryList[self.currentIndex]["options"]):
selectionPath = self.entryList[
self.currentIndex]["options"]["selectionPath"]
else:
selectionPath = "/"
self.subComponent = FileChooser.FileChooser(
self.screen, self.entryList[self.currentIndex]["options"]["name"],
selectionPath, False, options, self.selectionCallback)
footer = Footer.Footer([("theme/direction.png", "select")],
[("theme/b_button.png", "back"),
("theme/a_button.png", "select")],
(255, 255, 255))
self.subComponent.setFooter(footer)
def __init__(self, parent, window_name, message, padding = 10):
## THEME COLORS ##
self.theme = Theme.Theme(Resources.readLine("save/options.spi", 2))
self.root = parent
self.top = Toplevel(self.root)
self.top.transient(self.root)
self.top.title("Superpipe || " + window_name)
self.top["bg"] = self.theme.main_color
self.top.resizable(width = False, height = False)
top_frame = Frame(self.top, borderwidth = 0, bg = self.theme.main_color)
top_frame.pack(fill = "both", expand = True, padx = padding, pady = padding)
label = Label(top_frame, text = message, bg = self.theme.main_color, fg = self.theme.text_color)
label.pack(padx = 4, pady = 4)
ok_button = Button(top_frame, text = "OK", bg = self.theme.button_color1, activebackground = self.theme.over_button_color1, fg = self.theme.text_color, activeforeground = self.theme.text_color, bd = 0, width = 10, height = 1)
ok_button["command"] = self.top.destroy
ok_button.pack(padx = 4, pady = 4)
self.top.bind("<Return>", lambda event: self.top.destroy())
self.top.bind("<Escape>", lambda event: self.top.destroy())
self.top.update_idletasks()
w = self.top.winfo_screenwidth()
h = self.top.winfo_screenheight()
size = tuple(int(_) for _ in self.top.geometry().split("+")[0].split("x"))
x = w/2 - size[0]/2
y = h/2 - size[1]/2
self.top.geometry("%dx%d+%d+%d" % (size + (x, y)))
self.top.iconbitmap("img/icon.ico")
self.top.focus()
def create(self, shortcut, filename, size=0):
shortcut = shortcut.replace(' ','')
ret, msg = self._checkShortcut(shortcut)
if not ret:
return ( ret ,msg )
if gtk.gdk.pixbuf_get_file_info(filename) == None:
return ( False , _('No Image selected') )
size_tab = (19,50)
if size > 1:
size = 1
type = 'png'
if gtk.gdk.pixbuf_get_file_info(filename)[0]['name'] == 'gif':
pixbufAni = gtk.gdk.PixbufAnimation( filename )
if pixbufAni.is_static_image():
pixbuf = pixbufAni.get_static_image()
else:
type = 'gif'
if type != 'gif':
pixbuf = gtk.gdk.pixbuf_new_from_file( filename )
if pixbuf.get_width() > size_tab[size] and \
pixbuf.get_height() > size_tab[size]:
pixbuf = Theme.resizePixbuf( pixbuf, size_tab[size], size_tab[size] )
f = open(filename, 'rb')
hash = sha.new(f.read()).hexdigest()
f.close()
dest = self.CEPath + PATH.DIR_SEP + pathquote(shortcut) + '.' + \
hash + '.' + type
if type == 'gif':
shutil.copyfile( filename, dest )
else:
pixbuf.save( dest, type )
self.msnOM.create( id=shortcut, filename=dest, type=2 )
self.list.update( {shortcut:dest} )
self.saveMap()
return ( True, '' )
def initOptionText(self):
self.optionsText = []
font = pygame.font.Font('theme/NotoSans-Regular.ttf', 14)
for opt in self.options:
text = font.render(
opt, True,
Theme.getColor("selectionMenu/fontColor", (55, 55, 55)))
self.optionsText.append(text)
def renderBackground(self):
self.background = pygame.Surface((self.width, self.height))
self.background.fill(
Theme.getColor("selectionMenu/backgroundColor", (255, 255, 255)))
self.maxRenderItems = int(self.height / self.optionHeight)
for x in range(1, int(self.height / self.optionHeight)):
pass
def cellLayoutFunc(self, layout, cell, model, iter):
"""show pixbuf for status"""
item = model[iter][2]
if item == None:
return
if item == "connected":
item = "online"
pixbuf = self.controller.theme.statusToPixbuf(item)
cell.set_property("pixbuf", Theme.resizePixbuf(pixbuf, 16, 16))
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
w, h = font.getStringSize(" ")
Theme.setSelectedColor()
font.render(str("Importing Songs"), (.05, .05 - v))
if self.stageInfoText:
font.render("%s (%d%%)" % (self.stageInfoText, 100 * self.stageProgress), (.05, .7 + v), scale = 0.001)
Theme.setBaseColor()
Dialogs.wrapText(font, (.1, .3 + v), self.statusText)
finally:
self.engine.view.resetProjection()
def cellLayoutFunc(self, layout, cell, model, iter):
'''show pixbuf for status'''
item = model[iter][2]
if item == None:
return
if item == 'connected':
item = 'online'
pixbuf = self.controller.theme.statusToPixbuf(item)
cell.set_property('pixbuf', Theme.resizePixbuf(pixbuf, 16, 16))
def cellLayoutFunc(self, layout, cell, model, iter):
'''show pixbuf for status'''
item = model[iter][2]
if item == None:
return
if item == 'connected':
item = 'online'
pixbuf = self.controller.theme.statusToPixbuf(item)
cell.set_property('pixbuf', Theme.resizePixbuf(pixbuf, 16, 16))
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
w, h = font.getStringSize(" ")
Theme.setSelectedColor()
font.render(_("Importing Songs"), (.05, .05 - v))
if self.stageInfoText:
font.render("%s (%d%%)" % (self.stageInfoText, 100 * self.stageProgress), (.05, .7 + v), scale = 0.001)
Theme.setBaseColor()
Dialogs.wrapText(font, (.1, .3 + v), self.statusText)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
if not visibility:
return
self.engine.view.setOrthogonalProjection(normalize = True)
try:
v = (1 - visibility) ** 2
font = self.engine.data.font
if self.fadeScreen:
Dialogs.fadeScreen(v)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
n = len(self.choices)
x, y = self.pos
w, h = font.getStringSize("_")
for i, choice in enumerate(self.choices[self.viewOffset:self.viewOffset + self.viewSize]):
text = choice.getText(i + self.viewOffset == self.currentIndex)
glPushMatrix()
glRotate(v * 45, 0, 0, 1)
# Draw arrows if scrolling is needed to see all items
if i == 0 and self.viewOffset > 0:
Theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / self.viewOffset) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, -1), s = .015)
glPopMatrix()
elif i == self.viewSize - 1 and self.viewOffset + self.viewSize < n:
Theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / (n - self.viewOffset - self.viewSize)) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, 1), s = .015)
glPopMatrix()
if i + self.viewOffset == self.currentIndex:
a = (math.sin(self.time) * .15 + .75) * (1 - v * 2)
Theme.setSelectedColor(a)
a *= -.005
glTranslatef(a, a, a)
else:
Theme.setBaseColor(1 - v)
font.render(text, (x - v / 4, y))
v *= 2
y += h
glPopMatrix()
finally:
self.engine.view.resetProjection()
def renderTextField(self, screen):
field = pygame.Surface(
(self.config["screenWidth"] - (self.config["screenWidth"] * 0.2),
30))
field.fill(Theme.getColor("textInput/buttonColor", (191, 191, 191)))
textSurface = self.textFont.render(
self.currentText, True,
Theme.getColor("textInput/fontColor", (0, 0, 0)))
field.blit(textSurface,
(0, (field.get_height() - textSurface.get_height()) / 2))
pygame.draw.line(field, Theme.getColor("textInput/fontColor",
(0, 0, 0)),
(textSurface.get_width(), 25),
(textSurface.get_width() + 10, 25), 2)
textX = (self.config["screenWidth"] - field.get_width()) / 2
screen.blit(field, (textX, 20))
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize=True)
font = self.engine.data.font
try:
v = (1 - visibility)**2
fadeScreen(v)
Theme.setBaseColor(1 - v)
pos = wrapText(font, (.1, .33 - v), self.prompt)
Theme.setSelectedColor(1 - v)
if self.key is not None:
text = pygame.key.name(self.key).capitalize()
pos = wrapText(font, (.1, (pos[1] + v) + .08 + v / 4), text)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
fadeScreen(v)
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
wrapText(font, (.1, .2 - v), self.prompt)
if self.bpm is not None:
Theme.setSelectedColor(1 - v)
wrapText(font, (.1, .5 + v), _("%.2f beats per minute") % (self.bpm))
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
v = (1 - visibility) ** 2
fadeScreen(v)
Theme.setBaseColor(1 - v)
pos = wrapText(font, (.1, .33 - v), self.prompt)
Theme.setSelectedColor(1 - v)
if self.key is not None:
text = pygame.key.name(self.key).capitalize()
pos = wrapText(font, (.1, (pos[1] + v) + .08 + v / 4), text)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
fadeScreen(v)
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
wrapText(font, (.1, .2 - v), self.prompt)
if self.bpm is not None:
Theme.setSelectedColor(1 - v)
wrapText(font, (.1, .5 + v), _("%.2f beats per minute") % (self.bpm))
finally:
self.engine.view.resetProjection()
def initTheme(self):
'''
loads the current theme
'''
self.theme = Theme(self.setting.get('gui_theme_name','DarkBlue'), self.screen)
self.theme.load()
self.images, self.colours, self.fonts = {}, {}, {}
for k, v in self.theme.images.iteritems():
self.images[k] = Tkinter.PhotoImage(file = os.path.join(self.theme.basepath, v))
self.colours = self.theme.colours
for k, v in self.theme.fonts.iteritems():
self.fonts[k] = tkFont.Font(family=v['family'], size=v['size'])
def __init__(self, screen, options, callback, width=150):
print("Opened Options menu ", options)
self.options = options
self.callback = callback
self.width = width
self.selection = pygame.Surface((self.width, self.optionHeight),
pygame.SRCALPHA)
self.selection.fill(
Theme.getColor("selectionMenu/selectionColor", (55, 55, 55, 120)))
self.init()
self.initOptionText()
def renderTracks(self, visibility):
w = self.boardWidth / self.strings
v = 1.0 - visibility
if self.editorMode:
x = (self.strings / 2 - self.selectedString) * w
s = 2 * w / self.strings
z1 = -0.5 * visibility ** 2
z2 = (self.boardLength - 0.5) * visibility ** 2
glColor4f(1, 1, 1, .15)
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(x - s, 0, z1)
glVertex3f(x + s, 0, z1)
glVertex3f(x - s, 0, z2)
glVertex3f(x + s, 0, z2)
glEnd()
sw = 0.035
glEnable(GL_TEXTURE_2D)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
Theme.setBaseColor(1 - v)
self.stringDrawing.texture.bind()
for n in range(self.strings - 1, -1, -1):
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex3f((n - self.strings / 2) * w - sw, -v, -2)
glTexCoord2f(1.0, 0.0)
glVertex3f((n - self.strings / 2) * w + sw, -v, -2)
glTexCoord2f(0.0, 1.0)
glVertex3f((n - self.strings / 2) * w - sw, -v, self.boardLength)
glTexCoord2f(1.0, 1.0)
glVertex3f((n - self.strings / 2) * w + sw, -v, self.boardLength)
glEnd()
v *= 2
glDisable(GL_TEXTURE_2D)
def renderTracks(self, visibility):
w = self.boardWidth / self.strings
v = 1.0 - visibility
if self.editorMode:
x = (self.strings / 2 - self.selectedString) * w
s = 2 * w / self.strings
z1 = -0.5 * visibility ** 2
z2 = (self.boardLength - 0.5) * visibility ** 2
glColor4f(1, 1, 1, .15)
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(x - s, 0, z1)
glVertex3f(x + s, 0, z1)
glVertex3f(x - s, 0, z2)
glVertex3f(x + s, 0, z2)
glEnd()
sw = 0.035
glEnable(GL_TEXTURE_2D)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
Theme.setBaseColor(1 - v)
self.stringDrawing.texture.bind()
for n in range(self.strings - 1, -1, -1):
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex3f((n - self.strings / 2) * w - sw, -v, -2)
glTexCoord2f(1.0, 0.0)
glVertex3f((n - self.strings / 2) * w + sw, -v, -2)
glTexCoord2f(0.0, 1.0)
glVertex3f((n - self.strings / 2) * w - sw, -v, self.boardLength)
glTexCoord2f(1.0, 1.0)
glVertex3f((n - self.strings / 2) * w + sw, -v, self.boardLength)
glEnd()
v *= 2
glDisable(GL_TEXTURE_2D)
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
if not font:
return
try:
v = (1 - visibility) ** 2
fadeScreen(v)
x = .1
y = .3 + v * 2
Theme.setBaseColor(1 - v)
pos = wrapText(font, (x, y), self.text, visibility = v)
w, h = font.getStringSize(self.prompt, scale = 0.001)
x = .5 - w / 2
y = pos[1] + 3 * h + v * 2
Theme.setSelectedColor(1 - v)
font.render(self.prompt, (x, y), scale = 0.001)
finally:
self.engine.view.resetProjection()
def render(self, visibility, topMost):
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
if not font:
return
try:
v = (1 - visibility) ** 2
fadeScreen(v)
x = .1
y = .3 + v * 2
Theme.setBaseColor(1 - v)
pos = wrapText(font, (x, y), self.text, visibility = v)
w, h = font.getStringSize(self.prompt, scale = 0.001)
x = .5 - w / 2
y = pos[1] + 3 * h + v * 2
Theme.setSelectedColor(1 - v)
font.render(self.prompt, (x, y), scale = 0.001)
finally:
self.engine.view.resetProjection()
def renderIcons(self, screen):
powerYPos = self.config["screenHeight"] - 30
powerXPos = self.config["screenWidth"] - 50
color = Theme.getColor("main/iconColor", (255, 255, 255, 120))
colorSelect = Theme.getColor("main/iconColor_select",
(255, 255, 255, 255))
if (self.powerFinal == None):
self.powerFinal = self.power.convert_alpha().copy()
self.powerFinal.fill(color, None, pygame.BLEND_RGBA_MULT)
if (self.powerSelect == None):
self.powerSelect = self.power.convert_alpha().copy()
self.powerSelect.fill(colorSelect, None, pygame.BLEND_RGBA_MULT)
if (self.selection == "power"):
screen.blit(self.powerSelect, (powerXPos, powerYPos))
else:
screen.blit(self.powerFinal, (powerXPos, powerYPos))
settingsYPos = self.config["screenHeight"] - 30
settingsXPos = 30
if (self.gearFinal == None):
self.gearFinal = self.gear.convert_alpha().copy()
self.gearFinal.fill(color, None, pygame.BLEND_RGBA_MULT)
if (self.gearSelect == None):
self.gearSelect = self.gear.convert_alpha().copy()
self.gearSelect.fill(colorSelect, None, pygame.BLEND_RGBA_MULT)
if (self.selection == "settings"):
screen.blit(self.gearSelect, (settingsXPos, settingsYPos))
else:
screen.blit(self.gearFinal, (settingsXPos, settingsYPos))
def renderBars(self, visibility, song, pos):
if not song:
return
w = self.boardWidth
v = 1.0 - visibility
sw = 0.02
beatsPerUnit = self.beatsPerBoard / self.boardLength
pos -= self.lastBpmChange
offset = pos / self.currentPeriod * beatsPerUnit
currentBeat = pos / self.currentPeriod
beat = int(currentBeat)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glPushMatrix()
while beat < currentBeat + self.beatsPerBoard:
z = (beat - currentBeat) / beatsPerUnit
if z > self.boardLength * .8:
c = (self.boardLength - z) / (self.boardLength * .2)
elif z < 0:
c = max(0, 1 + z)
else:
c = 1.0
glRotate(v * 90, 0, 0, 1)
if (beat % 1.0) < 0.001:
Theme.setBaseColor(visibility * c * .75)
else:
Theme.setBaseColor(visibility * c * .5)
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(-(w / 2), -v, z + sw)
glVertex3f(-(w / 2), -v, z - sw)
glVertex3f(w / 2, -v, z + sw)
glVertex3f(w / 2, -v, z - sw)
glEnd()
if self.editorMode:
beat += 1.0 / 4.0
else:
beat += 1
glPopMatrix()
Theme.setSelectedColor(visibility * .5)
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(-w / 2, 0, sw)
glVertex3f(-w / 2, 0, -sw)
glVertex3f(w / 2, 0, sw)
glVertex3f(w / 2, 0, -sw)
glEnd()
def renderTracks(self, visibility):
w = self.boardWidth / self.strings
v = 1.0 - visibility
if self.editorMode:
x = (self.strings / 2 - self.selectedString) * w
s = 2 * w / self.strings
z1 = -0.5 * visibility ** 2
z2 = (self.boardLength - 0.5) * visibility ** 2
glColor4f(1, 1, 1, .15)
glBegin(GL_TRIANGLE_STRIP)
glVertex3f(x - s, 0, z1)
glVertex3f(x + s, 0, z1)
glVertex3f(x - s, 0, z2)
glVertex3f(x + s, 0, z2)
glEnd()
sw = 0.025
for n in range(self.strings - 1, -1, -1):
glBegin(GL_TRIANGLE_STRIP)
Theme.setBaseColor(0)
glVertex3f((n - self.strings / 2) * w - sw, -v, -2)
glVertex3f((n - self.strings / 2) * w + sw, -v, -2)
Theme.setBaseColor((1.0 - v) * .75)
glVertex3f((n - self.strings / 2) * w - sw, -v, -1)
glVertex3f((n - self.strings / 2) * w + sw, -v, -1)
Theme.setBaseColor((1.0 - v) * .75)
glVertex3f((n - self.strings / 2) * w - sw, -v, self.boardLength * .7)
glVertex3f((n - self.strings / 2) * w + sw, -v, self.boardLength * .7)
Theme.setBaseColor(0)
glVertex3f((n - self.strings / 2) * w - sw, -v, self.boardLength)
glVertex3f((n - self.strings / 2) * w + sw, -v, self.boardLength)
glEnd()
v *= 2
def render(self, visibility, topMost):
v = (1 - visibility) ** 2
# render the background
t = self.time / 100
w, h, = self.engine.view.geometry[2:4]
r = .5
self.background.transform.reset()
self.background.transform.translate(v * 2 * w + w / 2 + math.sin(t / 2) * w / 2 * r, h / 2 + math.cos(t) * h / 2 * r)
self.background.transform.rotate(-t)
self.background.transform.scale(math.sin(t / 8) + 2, math.sin(t / 8) + 2)
self.background.draw()
# render the item list
try:
glMatrixMode(GL_PROJECTION)
glPushMatrix()
glLoadIdentity()
gluPerspective(60, self.engine.view.aspectRatio, 0.1, 1000)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glEnable(GL_DEPTH_TEST)
glDisable(GL_CULL_FACE)
glDepthMask(1)
offset = 10 * (v ** 2)
self.camera.origin = (-10 + offset, -self.cameraOffset, 4 + offset)
self.camera.target = ( 0 + offset, -self.cameraOffset, 2.5 + offset)
self.camera.apply()
y = 0.0
for i, item in enumerate(self.items):
if not self.matchesSearch(item):
continue
c = math.sin(self.itemAngles[i] * math.pi / 180)
if isinstance(item, Song.SongInfo):
h = c * self.cassetteWidth + (1 - c) * self.cassetteHeight
else:
h = c * self.libraryWidth + (1 - c) * self.libraryHeight
d = (y + h * .5 + self.camera.origin[1]) / (4 * (self.camera.target[2] - self.camera.origin[2]))
if i == self.selectedIndex:
self.selectedOffset = y + h / 2
Theme.setSelectedColor()
else:
Theme.setBaseColor()
glTranslatef(0, -h / 2, 0)
glPushMatrix()
if abs(d) < 1.2:
if isinstance(item, Song.SongInfo):
glRotate(self.itemAngles[i], 0, 0, 1)
self.renderCassette(item.cassetteColor, self.itemLabels[i])
elif isinstance(item, Song.LibraryInfo):
glRotate(-self.itemAngles[i], 0, 0, 1)
if i == self.selectedIndex:
glRotate(self.time * 4, 1, 0, 0)
self.renderLibrary(item.color, self.itemLabels[i])
glPopMatrix()
glTranslatef(0, -h / 2, 0)
y += h
glDisable(GL_DEPTH_TEST)
glDisable(GL_CULL_FACE)
glDepthMask(0)
finally:
glMatrixMode(GL_PROJECTION)
glPopMatrix()
glMatrixMode(GL_MODELVIEW)
# render the song info
self.engine.view.setOrthogonalProjection(normalize = True)
font = self.engine.data.font
try:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
Theme.setBaseColor(1 - v)
if self.searchText:
text = _("Filter: %s") % (self.searchText) + "|"
if not self.matchesSearch(self.items[self.selectedIndex]):
text += " (%s)" % _("Not found")
font.render(text, (.05, .7 + v), scale = 0.001)
elif self.songLoader:
font.render(_("Loading Preview..."), (.05, .7 + v), scale = 0.001)
x = .6
y = .15
font.render(self.prompt, (x, .05 - v))
Theme.setSelectedColor(1 - v)
item = self.items[self.selectedIndex]
if self.matchesSearch(item):
angle = self.itemAngles[self.selectedIndex]
f = ((90.0 - angle) / 90.0) ** 2
pos = wrapText(font, (x, y), item.name, visibility = f, scale = 0.0016)
if isinstance(item, Song.SongInfo):
Theme.setBaseColor(1 - v)
wrapText(font, (x, pos[1] + font.getHeight() * 0.0016), item.artist, visibility = f, scale = 0.0016)
Theme.setSelectedColor(1 - v)
scale = 0.0011
w, h = font.getStringSize(self.prompt, scale = scale)
x = .6
y = .5 + f / 2.0
if len(item.difficulties) > 3:
y = .42 + f / 2.0
for d in item.difficulties:
scores = item.getHighscores(d)
if scores:
score, stars, name = scores[0]
else:
score, stars, name = "---", 0, "---"
Theme.setBaseColor(1 - v)
font.render(unicode(d), (x, y), scale = scale)
font.render(unicode(Data.STAR2 * stars + Data.STAR1 * (5 - stars)), (x, y + h), scale = scale * .9)
Theme.setSelectedColor(1 - v)
font.render(unicode(score), (x + .15, y), scale = scale)
font.render(name, (x + .15, y + h), scale = scale)
y += 2 * h + f / 4.0
elif isinstance(item, Song.LibraryInfo):
Theme.setBaseColor(1 - v)
if item.songCount == 1:
songCount = _("One song in this library")
else:
songCount = _("%d songs in this library") % item.songCount
wrapText(font, (x, pos[1] + 3 * font.getHeight() * 0.0016), songCount, visibility = f, scale = 0.0016)
finally:
self.engine.view.resetProjection()
def setColor(self, color):
self._set("color", Theme.colorToHex(color))
def getColor(self):
c = self._get("color")
if c:
return Theme.hexToColor(c)
def render(self, visibility, topMost):
#MFH - display version in any menu:
if not visibility:
self.active = False
return
self.active = True
self.engine.view.setOrthogonalProjection(normalize = True)
try:
v = (1 - visibility) ** 2
# Default to this font if none was specified
if self.font == "font":
font = self.engine.data.font
else:
font = self.font
if self.fadeScreen:
Dialogs.fadeScreen(v)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
n = len(self.choices)
x, y = self.pos
for i, choice in enumerate(self.choices[self.viewOffset:self.viewOffset + self.viewSize]):
text = choice.getText(i + self.viewOffset == self.currentIndex)
glPushMatrix()
glRotate(v * 45, 0, 0, 1)
if self.theme == 0 and self.mainMenu:#8bit
if not i % 2 == 1:
scale = 0.002
else:
scale = 0.0016
elif self.theme == 1 and self.mainMenu:
if not i % 2 == 1:
scale = 0.002
else:
scale = 0.0016
else:
scale = 0.002
w, h = font.getStringSize(" ", scale = scale)
# Draw arrows if scrolling is needed to see all items
if i == 0 and self.viewOffset > 0:
Theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / self.viewOffset) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, -1), s = .015)
glPopMatrix()
elif i == self.viewSize - 1 and self.viewOffset + self.viewSize < n:
Theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / (n - self.viewOffset - self.viewSize)) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, 1), s = .015)
glPopMatrix()
if i + self.viewOffset == self.currentIndex:
a = (math.sin(self.time) * .15 + .75) * (1 - v * 2)
Theme.setSelectedColor(a)
a *= -.005
glTranslatef(a, a, a)
else:
Theme.setBaseColor(1 - v)
#MFH - settable color through Menu constructor
if i + self.viewOffset == self.currentIndex and self.selectedColor:
c1,c2,c3 = self.selectedColor
glColor3f(c1,c2,c3)
elif self.textColor:
c1,c2,c3 = self.textColor
glColor3f(c1,c2,c3)
#MFH - now to catch " >" main menu options and blank them:
if text == " >":
text = ""
font.render(text, (x - v / 4, y), scale = scale)
v *= 2
if self.theme == 1 and self.font == self.engine.data.pauseFont: # evilynux - Ugly workaround for Gh3
y += h*.75
else:
y += h
glPopMatrix()
finally:
self.engine.view.resetProjection()
def __init__(self, config = None):
"""
Constructor.
@param config: L{Config} instance for settings
"""
if not config:
config = Config.load()
self.config = config
fps = self.config.get("video", "fps")
tickrate = self.config.get("engine", "tickrate")
Engine.__init__(self, fps = fps, tickrate = tickrate)
pygame.init()
self.title = _("Frets on Fire")
self.restartRequested = False
self.handlingException = False
self.video = Video(self.title)
self.audio = Audio()
Log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.pre_open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
pygame.init()
self.audio.open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
Log.debug("Initializing video.")
width, height = [int(s) for s in self.config.get("video", "resolution").split("x")]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height), fullscreen = fullscreen, multisamples = multisamples)
# Enable the high priority timer if configured
if self.config.get("engine", "highpriority"):
Log.debug("Enabling high priority timer.")
self.timer.highPriority = True
viewport = glGetIntegerv(GL_VIEWPORT)
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.img = ImgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.server = None
self.sessions = []
self.mainloop = self.loading
# Load game modifications
Mod.init(self)
theme = Config.load(self.resource.fileName("theme.ini"))
Theme.open(theme)
# Make sure we are using the new upload URL
if self.config.get("game", "uploadurl").startswith("http://kempele.fi"):
self.config.set("game", "uploadurl", "http://fretsonfire.sourceforge.net/play")
self.addTask(self.audio, synchronized = False)
self.addTask(self.input, synchronized = False)
self.addTask(self.view)
self.addTask(self.resource, synchronized = False)
self.data = Data(self.resource, self.img)
self.input.addKeyListener(FullScreenSwitcher(self), priority = True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
Log.debug("Ready.")
def getCassetteColor(self):
c = self._get("cassettecolor")
if c:
return Theme.hexToColor(c)
def render(self, visibility, topMost):
self.engine.view.setViewport(1,0)
SceneClient.render(self, visibility, topMost)
bigFont = self.engine.data.bigFont
font = self.engine.data.font
v = ((1 - visibility) ** 2)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
self.engine.view.setOrthogonalProjection(normalize = True)
try:
t = self.time / 100
w, h, = self.engine.view.geometry[2:4]
r = .5
if self.background:
imgwidth = self.background.width1()
wfactor = 640.000/imgwidth
self.background.transform.reset()
#self.background.transform.scale(1,-1)
self.background.transform.scale(wfactor,-wfactor)
self.background.transform.translate(w/2,h/2)
self.background.draw()
if self.showHighscores:
for j,player in enumerate(self.playerList):
#self.engine.view.setViewportHalf(len(self.playerList),j)
scale = 0.0017
endScroll = -.14
if self.pauseScroll != None:
self.offset = 0.0
if self.pauseScroll > 0.5:
self.pauseScroll = None
if self.offset == None:
self.offset = 0
self.pauseScroll = 0
self.nextHighScore()
# evilynux - highscore
if self.song is not None:
text = _("%s High Scores for %s") % (self.scorePart, self.song.info.name)
else:
text = _("%s High Scores") % self.scorePart
w, h = font.getStringSize(text)
Theme.setBaseColor(1 - v)
font.render(text, (.5 - w / 2, .01 - v + self.offset))
text = _("Difficulty: %s") % (self.scoreDifficulty)
w, h = font.getStringSize(text)
Theme.setBaseColor(1 - v)
font.render(text, (.5 - w / 2, .01 - v + h + self.offset))
x = .01
y = .16 + v
if self.song:
i = -1
for i, scores in enumerate(self.song.info.getHighscores(self.scoreDifficulty, part = self.scorePart)):
score, stars, name, scores_ext = scores
notesHit, notesTotal, noteStreak, modVersion, modOptions1, modOptions2 = scores_ext
if stars == 6:
stars = 5
perfect = 1
else:
perfect = 0
for j,player in enumerate(self.playerList):
if (self.time % 10.0) < 5.0 and i == self.highscoreIndex[j] and self.scoreDifficulty == player.difficulty and self.scorePart == player.part:
Theme.setSelectedColor(1 - v)
break
else:
Theme.setBaseColor(1 - v)
font.render("%d." % (i + 1), (x, y + self.offset), scale = scale)
if notesTotal != 0:
score = "%s %.1f%%" % (score, (float(notesHit) / notesTotal) * 100.0)
if noteStreak != 0:
score = "%s (%d)" % (score, noteStreak)
font.render(unicode(score), (x + .05, y + self.offset), scale = scale)
options = ""
w2, h2 = font.getStringSize(options, scale = scale / 2)
font.render(unicode(options), (.6 - w2, y + self.offset), scale = scale / 2)
# evilynux - Fixed star size following Font render bugfix
if perfect == 1 and self.theme == 2:
glColor3f(1, 1, 0) #racer: perfect is now gold for rock band
font.render(unicode(Data.STAR2 * stars + Data.STAR1 * (5 - stars)), (x + .6, y + self.offset), scale = scale * 1.8)
if perfect == 1 and self.theme < 2:
glColor3f(0, 1, 0) #racer: perfect is green for any non-RB theme
font.render(unicode(Data.STAR2 * stars + Data.STAR1 * (5 - stars)), (x + .6, y + self.offset), scale = scale * 1.8)
for j,player in enumerate(self.playerList):
if (self.time % 10.0) < 5.0 and i == self.highscoreIndex[j] and self.scoreDifficulty == player.difficulty and self.scorePart == player.part:
Theme.setSelectedColor(1 - v)
break
else:
Theme.setBaseColor(1 - v)
font.render(name, (x + .8, y + self.offset), scale = scale)
y += h
endScroll -= .07
if self.offset < endScroll or i == -1:
self.offset = .8
self.nextHighScore()
endScroll = -0.14
if self.uploadingScores and self.uploadResult is None:
Theme.setBaseColor(1 - v)
font.render(_("Uploading Scores..."), (.05, .7 + v), scale = 0.001)
return
Theme.setBaseColor(1 - v)
if self.playerList[0].cheating:
text = _("%s Cheated!") % self.song.info.name
else:
text = _("%s Finished!") % self.song.info.name
w, h = font.getStringSize(text)
Dialogs.wrapText(font, (.05, .045 - v), text)
text = "%d/" % self.hits
text2 = _("%d notes hit") % self.totalnotes
text = text + text2
w, h = font.getStringSize(text)
Dialogs.wrapText(font, (.5 - w / 2, .54 - v - h), text)
for j,player in enumerate(self.playerList):
if self.playerList[j].cheating:
self.stars[j] = 0
self.accuracy[j] = 0.0
self.engine.view.setViewportHalf(len(self.playerList),j)
text = "%d" % (player.score * self.anim(1000, 2000))
w, h = bigFont.getStringSize(text)
bigFont.render(text, (.5 - w / 2, .11 + v + (1.0 - self.anim(0, 1000) ** 3)), scale = 0.0025)
if self.counter > 1000:
scale = 0.0017
if self.stars[j] == 6 and self.theme == 2: #racer: gold perfect for RB
glColor3f(1, 1, 0)
text = (Data.STAR2 * (self.stars[j] - 1))
elif self.stars[j] == 6 and self.theme < 2: #racer: green perfect for non-RB
glColor3f(0, 1, 0)
text = (Data.STAR2 * (self.stars[j] - 1))
else:
text = (Data.STAR2 * self.stars[j] + Data.STAR1 * (5 - self.stars[j]))
w, h = bigFont.getStringSize(Data.STAR1, scale = scale)
x = .5 - w * len(text) / 2
for i, ch in enumerate(text):
bigFont.render(ch, (x + 100 * (1.0 - self.anim(1000 + i * 200, 1000 + (i + 1) * 200)) ** 2, .35 + v), scale = scale)
x += w
if self.counter > 2500:
Theme.setBaseColor(1 - v)
text = _("Accuracy: %.1f%%") % self.accuracy[j]
w, h = font.getStringSize(text)
font.render(text, (.5 - w / 2, .55 + v))
text = _("Longest note streak: %d") % player.longestStreak
w, h = font.getStringSize(text)
font.render(text, (.5 - w / 2, .55 + h + v))
if player.twoChord > 0:
text = _("Part: %s on %s (2 chord)") % (player.part, player.difficulty)
else:
text = _("Part: %s on %s") % (player.part, player.difficulty)
w, h = font.getStringSize(text)
font.render(text, (.5 - w / 2, .55 + (2 * h)+ v))
self.engine.view.setViewport(1,0)
finally:
self.engine.view.setViewport(1,0)
self.engine.view.resetProjection()
def render(self, visibility, topMost):
SceneClient.render(self, visibility, topMost)
font = self.engine.data.font
bigFont = self.engine.data.bigFont
self.visibility = v = 1.0 - ((1 - visibility) ** 2)
self.engine.view.setOrthogonalProjection(normalize = True)
try:
# show countdown
if self.countdown > 1:
Theme.setBaseColor(min(1.0, 3.0 - abs(4.0 - self.countdown)))
text = _("Get Ready to Rock")
w, h = font.getStringSize(text)
font.render(text, (.5 - w / 2, .3))
if self.countdown < 6:
scale = 0.002 + 0.0005 * (self.countdown % 1) ** 3
text = "%d" % (self.countdown)
w, h = bigFont.getStringSize(text, scale = scale)
Theme.setSelectedColor()
bigFont.render(text, (.5 - w / 2, .45 - h / 2), scale = scale)
w, h = font.getStringSize(" ")
y = .05 - h / 2 - (1.0 - v) * .2
# show song name
if self.countdown and self.song:
Theme.setBaseColor(min(1.0, 4.0 - abs(4.0 - self.countdown)))
Dialogs.wrapText(font, (.05, .05 - h / 2), self.song.info.name + " \n " + self.song.info.artist, rightMargin = .6, scale = 0.0015)
Theme.setSelectedColor()
font.render("%d" % (self.player.score + self.getExtraScoreForCurrentlyPlayedNotes()), (.6, y))
font.render("%dx" % self.player.getScoreMultiplier(), (.6, y + h))
# show the streak counter and miss message
if self.player.streak > 0 and self.song:
text = _("%d hit") % self.player.streak
factor = 0.0
if self.lastPickPos:
diff = self.getSongPosition() - self.lastPickPos
if diff > 0 and diff < self.song.period * 2:
factor = .25 * (1.0 - (diff / (self.song.period * 2))) ** 2
factor = (1.0 + factor) * 0.002
tw, th = font.getStringSize(text, scale = factor)
font.render(text, (.16 - tw / 2, y + h / 2 - th / 2), scale = factor)
elif self.lastPickPos is not None and self.countdown <= 0:
diff = self.getSongPosition() - self.lastPickPos
alpha = 1.0 - diff * 0.005
if alpha > .1:
Theme.setSelectedColor(alpha)
glPushMatrix()
glTranslate(.1, y + 0.000005 * diff ** 2, 0)
glRotatef(math.sin(self.lastPickPos) * 25, 0, 0, 1)
font.render(_("Missed!"), (0, 0))
glPopMatrix()
# show the streak balls
if self.player.streak >= 30:
glColor3f(.5, .5, 1)
elif self.player.streak >= 20:
glColor3f(1, 1, .5)
elif self.player.streak >= 10:
glColor3f(1, .5, .5)
else:
glColor3f(.5, 1, .5)
s = min(39, self.player.streak) % 10 + 1
font.render(Data.BALL2 * s + Data.BALL1 * (10 - s), (.67, y + h * 1.3), scale = 0.0011)
# show multiplier changes
if self.song and self.lastMultTime is not None:
diff = self.getSongPosition() - self.lastMultTime
if diff > 0 and diff < self.song.period * 2:
m = self.player.getScoreMultiplier()
c = (1, 1, 1)
if self.player.streak >= 40:
texture = None
elif m == 1:
texture = None
elif m == 2:
texture = self.fx2x.texture
c = (1, .5, .5)
elif m == 3:
texture = self.fx3x.texture
c = (1, 1, .5)
elif m == 4:
texture = self.fx4x.texture
c = (.5, .5, 1)
f = (1.0 - abs(self.song.period * 1 - diff) / (self.song.period * 1)) ** 2
# Flash the screen
glBegin(GL_TRIANGLE_STRIP)
glColor4f(c[0], c[1], c[2], (f - .5) * 1)
glVertex2f(0, 0)
glColor4f(c[0], c[1], c[2], (f - .5) * 1)
glVertex2f(1, 0)
glColor4f(c[0], c[1], c[2], (f - .5) * .25)
glVertex2f(0, 1)
glColor4f(c[0], c[1], c[2], (f - .5) * .25)
glVertex2f(1, 1)
glEnd()
if texture:
glPushMatrix()
glEnable(GL_TEXTURE_2D)
texture.bind()
size = (texture.pixelSize[0] * .002, texture.pixelSize[1] * .002)
glTranslatef(.5, .15, 0)
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
f = .5 + .5 * (diff / self.song.period) ** 3
glColor4f(1, 1, 1, min(1, 2 - f))
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex2f(-size[0] * f, -size[1] * f)
glTexCoord2f(1.0, 0.0)
glVertex2f( size[0] * f, -size[1] * f)
glTexCoord2f(0.0, 1.0)
glVertex2f(-size[0] * f, size[1] * f)
glTexCoord2f(1.0, 1.0)
glVertex2f( size[0] * f, size[1] * f)
glEnd()
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glPopMatrix()
# show the comments
if self.song and self.song.info.tutorial:
glColor3f(1, 1, 1)
pos = self.getSongPosition()
for time, event in self.song.track.getEvents(pos - self.song.period * 2, pos + self.song.period * 4):
if isinstance(event, PictureEvent):
if pos < time or pos > time + event.length:
continue
try:
picture = event.picture
except:
self.engine.loadImgDrawing(event, "picture", os.path.join(self.libraryName, self.songName, event.fileName))
picture = event.picture
w, h, = self.engine.view.geometry[2:4]
fadePeriod = 500.0
f = (1.0 - min(1.0, abs(pos - time) / fadePeriod) * min(1.0, abs(pos - time - event.length) / fadePeriod)) ** 2
picture.transform.reset()
picture.transform.translate(w / 2, (f * -2 + 1) * h / 2)
picture.transform.scale(1, -1)
picture.draw()
elif isinstance(event, TextEvent):
if pos >= time and pos <= time + event.length:
text = _(event.text)
w, h = font.getStringSize(text)
font.render(text, (.5 - w / 2, .67))
finally:
self.engine.view.resetProjection()
def setCassetteColor(self, color):
self._set("cassettecolor", Theme.colorToHex(color))
