Example #1
0
    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(" ", "&nbsp;"))
                submenus += submenu_text + "</table>"

        return result + "<td style='width=100%'></td></tr></table>" + submenus
Example #2
0
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)
Example #4
0
 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()
Example #5
0
File: Dialogs.py Project: twcb/FoF
    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()
Example #6
0
  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()
Example #7
0
  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()
Example #8
0
  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()
Example #9
0
  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()
Example #10
0
  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()
Example #11
0
  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()
Example #12
0
    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(" ","&nbsp;"))
                submenus += submenu_text + "</table>"

        return result + "<td style='width=100%'></td></tr></table>" + submenus
Example #13
0
  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()
Example #14
0
    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()
Example #15
0
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)
Example #16
0
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)
Example #17
0
    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)
Example #18
0
 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."))
Example #19
0
 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."))
Example #20
0
  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()
Example #21
0
  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()
Example #22
0
  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()
Example #23
0
    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'])
Example #24
0
    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)))
Example #25
0
File: Menu.py Project: twcb/FoF
    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()
Example #26
0
    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()
Example #27
0
    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)
Example #28
0
	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()
Example #29
0
 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, '' )
Example #30
0
 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)
Example #31
0
    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))
Example #33
0
  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))
Example #35
0
 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))
Example #36
0
  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()
Example #37
0
  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()
Example #38
0
    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))
Example #39
0
File: Dialogs.py Project: twcb/FoF
    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()
Example #40
0
  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()
Example #41
0
  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()
Example #42
0
  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()
Example #43
0
	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'])
Example #44
0
    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()
Example #45
0
  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)
Example #46
0
  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)
Example #47
0
  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()
Example #48
0
  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()
Example #49
0
    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))
Example #50
0
  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()
Example #51
0
  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
Example #52
0
  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()
Example #53
0
 def setColor(self, color):
   self._set("color", Theme.colorToHex(color))
Example #54
0
 def getColor(self):
   c = self._get("color")
   if c:
     return Theme.hexToColor(c)
Example #55
0
  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()
Example #56
0
    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.")
Example #57
0
 def getCassetteColor(self):
   c = self._get("cassettecolor")
   if c:
     return Theme.hexToColor(c)
Example #58
0
  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()
Example #59
0
    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()
Example #60
0
 def setCassetteColor(self, color):
   self._set("cassettecolor", Theme.colorToHex(color))