Esempio n. 1
0
    def enterDisplayPage(self):
        self.book.createPageButtons(False, False)
        self.book.setTitle("Display Options")
        dialog_gui = loader.loadModel(
            "phase_3/models/gui/dialog_box_buttons_gui.bam")
        width, height, fs, music, sfx, tex_detail, model_detail, aa, af = SettingsManager(
        ).getSettings("settings.json")
        self.width = width
        self.height = height
        self.windowType = [fs]
        self.buttons = [
            DirectRadioButton(text="Windowed",
                              variable=self.windowType,
                              value=[False],
                              scale=0.1,
                              pos=(-0.45, 0.15, 0.15)),
            DirectRadioButton(text="Fullscreen",
                              variable=self.windowType,
                              value=[True],
                              scale=0.1,
                              pos=(-0.45, -0.15, -0.15))
        ]

        for button in self.buttons:
            button.setOthers(self.buttons)

        self.resoLbl = DirectLabel(text="%sx%s" % (width, height),
                                   scale=0.08,
                                   relief=None,
                                   pos=(0.25, 0, 0))
        self.resSlider = DirectSlider(range=(0, 200),
                                      pageSize=50,
                                      command=self.setResoText,
                                      scale=0.3,
                                      orientation=DGG.VERTICAL,
                                      pos=(0.6, 0, 0))
        self.okBtn = DirectButton(text="OK",
                                  geom=CIGlobals.getOkayBtnGeom(),
                                  relief=None,
                                  pos=(-0.5, -0.5, -0.5),
                                  text_scale=0.05,
                                  text_pos=(0, -0.11),
                                  command=self.applyDisplaySettings)
        self.cancelBtn = DirectButton(text="Cancel",
                                      geom=CIGlobals.getCancelBtnGeom(),
                                      relief=None,
                                      pos=(-0.3, -0.5, -0.5),
                                      text_scale=0.05,
                                      text_pos=(0, -0.11),
                                      command=self.cancelDisplaySettings)
        if self.resoLbl['text'] == "640x480":
            self.resSlider['value'] = 0
        elif self.resoLbl['text'] == "800x600":
            self.resSlider['value'] = 50
        elif self.resoLbl['text'] == "1024x768":
            self.resSlider['value'] = 100
        elif self.resoLbl['text'] == "1280x1024":
            self.resSlider['value'] = 150
        elif self.resoLbl['text'] == "1600x1200":
            self.resSlider['value'] = 200
class MapConfig(DirectFrame):

    def __init__(self, *args, **kwargs):
        kwargs['suppressMouse'] = 0
        super(self.__class__, self).__init__(*args, **kwargs)
        self.initialiseoptions(self.__class__)
        self.setTransparency(1)
        self.setup()


    def setup(self):
        if hasattr(self, 'mainFrame'):
            self.mainFrame.destroy()

        self.mainFrame = DirectFrame(parent = self, relief = None)

        def setVisibility():
            value = self.visSlider['value']
            self.setColorScale(Vec4(1, 1, 1, value))

        self.visSlider = DirectSlider(guiId = 'visSlider', parent = self.mainFrame, scale = 0.40000000000000002, thumb_relief = DGG.FLAT, thumb_color = (0.25, 1.0, 0.25, 1), pos = (0.40000000000000002, 0, -0.84999999999999998), text = 'Visibility', text_scale = 0.20000000000000001, text_pos = (0, 0.10000000000000001, 0), text_bg = (0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 1), value = 1.0, command = setVisibility)
        self.visSlider.getChild(0).setTransparency(0)
        self.camFrame = DirectFrame(guiId = 'camFrame', parent = self.mainFrame, relief = DGG.RIDGE, frameSize = (0.0, 0.80000000000000004, 0.0, 0.32000000000000001), frameColor = (1, 1, 0.75, 1), borderWidth = (0.0050000000000000001, 0.0050000000000000001), pos = (0, 0, 0.59999999999999998), text = 'Camera', text_fg = (0, 0, 0, 1), text_scale = 0.050000000000000003, text_pos = (0.10000000000000001, 0.26000000000000001, 0))
        self.camSlider = RangeSlider(guiId = 'zoom', label = 'Zoom (Y-axis)', range = (-0.75, 0.25), value = 0, parent = self.camFrame, pos = (0.39500000000000002, 0, 0.070000000000000007))
        self.worldFrame = DirectFrame(guiId = 'worldFrame', parent = self.mainFrame, relief = DGG.RIDGE, frameSize = (0.0, 0.80000000000000004, -0.55000000000000004, 0.5), frameColor = (1, 0.75, 0.75, 1), borderWidth = (0.0050000000000000001, 0.0050000000000000001), pos = (0.0, 0, 0), text = 'World', text_fg = (0, 0, 0, 1), text_scale = 0.050000000000000003, text_pos = (0.10000000000000001, 0.42999999999999999, 0))
        self.worldPSlider = RangeSlider(guiId = 'worldP', label = 'World P', range = (-90, 0), value = 0.0, parent = self.worldFrame, pos = (0.39500000000000002, 0, 0.23999999999999999))
        self.worldDecorScaleSlider = RangeSlider(guiId = 'worldP', label = 'World Decor Scale', range = (0.20000000000000001, 0.29999999999999999), value = 0.25, parent = self.worldFrame, pos = (0.39500000000000002, 0, 0.0))
        self.finalSlider = RangeSlider(guiId = 'final', label = 'Final', range = (0, 1), value = 0, parent = self.worldFrame, pos = (0.39500000000000002, 0, -0.47999999999999998))
        self.saveState0Button = DirectButton(guiId = 'save0Button', parent = self.mainFrame, scale = 0.10000000000000001, pos = (0.20000000000000001, 0, -0.65000000000000002), borderWidth = (0.10000000000000001, 0.10000000000000001), text = 'save pt0')
        self.saveState1Button = DirectButton(guiId = 'save1Button', parent = self.mainFrame, scale = 0.10000000000000001, pos = (0.59999999999999998, 0, -0.65000000000000002), borderWidth = (0.10000000000000001, 0.10000000000000001), text = 'save pt1')
class SliderWidget(DirectFrame):
    notify = directNotify.newCategory("SliderWidget")

    def __init__(self, page, widgetname, slrange, slcommand, pos = (0, 0, 0)):
        DirectFrame.__init__(self, parent = page.book, pos = pos)

        self.page = page

        self.text = OnscreenText(text = widgetname + ":", pos = (-0.7, 0, 0), align = TextNode.ALeft, parent = self)
        self.slider = DirectSlider(range=slrange, pageSize=0.1, command=slcommand, scale=0.3,
                                        orientation=DGG.HORIZONTAL, pos=(0.35, 0, 0.025), parent = self)
        self.valText = OnscreenText(text = "", pos = (0.7, -0.005, -0.005), align = TextNode.ALeft, parent = self)

    def setValText(self, text):
        self.valText.setText(text)

    def getSliderVal(self):
        return self.slider['value']

    def setSliderVal(self, val):
        self.slider['value'] = val

    def cleanup(self):
        if hasattr(self, 'text'):
            self.text.destroy()
            del self.text
        if hasattr(self, 'slider'):
            self.slider.destroy()
            del self.slider
        if hasattr(self, 'valText'):
            self.valText.destroy()
            del self.valText
        del self.page
    def __init__(self, page, widgetname, slrange, slcommand, pos = (0, 0, 0)):
        DirectFrame.__init__(self, parent = page.book, pos = pos)

        self.page = page

        self.text = OnscreenText(text = widgetname + ":", pos = (-0.7, 0, 0), align = TextNode.ALeft, parent = self)
        self.slider = DirectSlider(range=slrange, pageSize=0.1, command=slcommand, scale=0.3,
                                        orientation=DGG.HORIZONTAL, pos=(0.35, 0, 0.025), parent = self)
        self.valText = OnscreenText(text = "", pos = (0.7, -0.005, -0.005), align = TextNode.ALeft, parent = self)
Esempio n. 5
0
class do4d(DirectObject, HasKeybinds):
    def __init__(self):
        tsteps = 10  # this is really molecules
        npoints = 999  # this is realy timesteps
        self.slider = DirectSlider(range=(0,1), value=0, pageSize=1, thumb_frameSize=(0,.04,-.02,.02), command=self.t_set)
        self.slider.setPos((0,0,-.9))

        data = np.cumsum(np.random.randint(-1,2,(tsteps,npoints,3)), axis=1)
        data2 = [data[:,i,:] for i in range(len(data[0]))]
        #embed()
        ctup = np.random.rand(tsteps, 4)
        tm1 = [treeMe(None, d, np.array(['%s'%uuid4() for _ in d]),np.ones(len(d))) for d in data]
        self.f1 = fourObject(make4d(data,ctup, geomType = GeomLinestrips), tm1 )
        sc1 = lambda: self.set_selected(self.f1)
        self.f1.coll_parent.setPythonTag('selection_callbacks', [sc1])
        self.set_selected(self.f1)

        tm2 = [treeMe(None, d, np.array(['%s'%uuid4() for _ in d]),np.ones(len(d))) for d in data2]
        self.f2 = fourObject(make4d(data2,ctup), tm2)
        self.f2.set_size(3)
        self.f2.stash()
        sc2 = lambda: self.set_selected(self.f2)
        self.f2.coll_parent.setPythonTag('selection_callbacks', [sc2])

        # TODO make clicking not on the button set the slider position?
        self.accept('s',self.set_selected, [self.f2])

    def set_selected(self, fourObject):  # TODO type check?
        self.selected = fourObject
        self.selected.unstash()
        self.slider['range'] = (0,len(self.selected)-1)
        self.slider['value'] = fourObject.__index__
        print('selected set to', fourObject)

    @event_callback('a')
    def t_all(self):
        if not self.selected._all:
            self.selected.show_all()
        else:
            self.selected.hide_all()
    

    def t_set(self):
        value = int(self.slider['value'])
        if value != self.selected.__index__:
            self.selected.goto_index(value)

    @event_callback((']',']-repeat'))
    def t_up(self):
        #self.selected.next_index()
        self.slider['value'] = (self.slider['value'] + 1) % len(self.selected)

    @event_callback(('[','[-repeat'))
    def t_down(self):
        #self.selected.prev_index()
        self.slider['value'] = (self.slider['value'] - 1) % len(self.selected)
Esempio n. 6
0
 def add_axis(offset, axis_name):
     slider_width = canvas_width / 2
     label = DirectLabel(
         text=axis_name,
         **left_aligned_small_text,
         pos=(0.05, 0, offset),
         parent=panel_canvas,
     )
     slider = DirectSlider(
         value=0.0,
         range=(-1.0, 1.0),
         state=DGG.DISABLED,
         frameSize=VBase4(
             0,
             slider_width,
             -0.1,
             0,
         ),
         thumb_frameSize=VBase4(
             0.0,
             0.04,
             -0.04,
             0.04),
         frameColor=VBase4(0.3, 0.3, 0.3, 1),
         pos=(canvas_width - slider_width, 0, offset),
         parent=panel_canvas,
     )
     return slider
Esempio n. 7
0
    def __init__(self):
        tsteps = 10  # this is really molecules
        npoints = 999  # this is realy timesteps
        self.slider = DirectSlider(range=(0,1), value=0, pageSize=1, thumb_frameSize=(0,.04,-.02,.02), command=self.t_set)
        self.slider.setPos((0,0,-.9))

        data = np.cumsum(np.random.randint(-1,2,(tsteps,npoints,3)), axis=1)
        data2 = [data[:,i,:] for i in range(len(data[0]))]
        #embed()
        ctup = np.random.rand(tsteps, 4)
        tm1 = [treeMe(None, d, np.array(['%s'%uuid4() for _ in d]),np.ones(len(d))) for d in data]
        self.f1 = fourObject(make4d(data,ctup, geomType = GeomLinestrips), tm1 )
        sc1 = lambda: self.set_selected(self.f1)
        self.f1.coll_parent.setPythonTag('selection_callbacks', [sc1])
        self.set_selected(self.f1)

        tm2 = [treeMe(None, d, np.array(['%s'%uuid4() for _ in d]),np.ones(len(d))) for d in data2]
        self.f2 = fourObject(make4d(data2,ctup), tm2)
        self.f2.set_size(3)
        self.f2.stash()
        sc2 = lambda: self.set_selected(self.f2)
        self.f2.coll_parent.setPythonTag('selection_callbacks', [sc2])

        # TODO make clicking not on the button set the slider position?
        self.accept('s',self.set_selected, [self.f2])
Esempio n. 8
0
 def add_vibration(offset, axis_name, index):
     slider_width = canvas_width / 2
     label = DirectLabel(
         text=axis_name,
         **left_aligned_small_text,
         pos=(0.05, 0, offset),
         parent=panel_canvas,
     )
     slider = DirectSlider(
         value=0.0,
         range=(0.0, 1.0),
         command=self.update_vibration,
         frameSize=VBase4(
             0,
             slider_width,
             -0.1,
             0,
         ),
         thumb_frameSize=VBase4(
             0.0,
             0.04,
             -0.04,
             0.04),
         frameColor=VBase4(0.3, 0.3, 0.3, 1),
         pos=(canvas_width - slider_width, 0, offset),
         parent=panel_canvas,
     )
     return slider
Esempio n. 9
0
    def setup(self, label, range, value, orientation, *args, **kwargs):
        def updateField(widget, field, value):
            widget[field] = value

        def finalCommand():
            val = self.slider['value']
            updateField(self.slider, 'text', '%1.3f' % val)

        self.slider = DirectSlider(parent=self,
                                   relief=DGG.FLAT,
                                   range=range,
                                   value=value,
                                   orientation=orientation,
                                   scale=0.25,
                                   thumb_relief=DGG.FLAT,
                                   thumb_color=(0, 1, 1, 1),
                                   pos=(0, 0, 0),
                                   text='0.0',
                                   text_scale=0.20000000000000001,
                                   text_pos=(0, 0.10000000000000001, 0))
        updateField(self.slider, 'command', finalCommand)
        width = 3
        if orientation == DGG.HORIZONTAL:
            pos = (-0.27500000000000002 - width * 0.050000000000000003, 0,
                   -0.02)
        else:
            pos = (-0.025000000000000001 * width, 0, -0.34999999999999998)
        self.min = DirectEntry(parent=self,
                               initialText=` float(self.slider['range'][0]) `,
                               scale=0.050000000000000003,
                               width=width,
                               pos=pos)
        updateField(
            self.min, 'command',
            lambda x: updateField(self.slider, 'range',
                                  (float(x), self.slider['range'][1])))
        if orientation == DGG.HORIZONTAL:
            pos = (0.27500000000000002, 0, -0.02)
        else:
            pos = (-0.025000000000000001 * width, 0, 0.29999999999999999)
        self.max = DirectEntry(parent=self,
                               initialText=` float(self.slider['range'][1]) `,
                               scale=0.050000000000000003,
                               width=width,
                               pos=pos)
        updateField(
            self.max, 'command',
            lambda x: updateField(self.slider, 'range',
                                  (self.slider['range'][0], float(x))))
        self.label = DirectLabel(
            parent=self,
            relief=None,
            text=label,
            text_scale=0.050000000000000003,
            text_pos=(0.029999999999999999 - 0.39500000000000002,
                      0.34999999999999998 - 0.23999999999999999, 0),
            text_align=TextNode.ALeft)
Esempio n. 10
0
    def createMaterialSliders(self):
        OnscreenText(text='Specular',
                     pos=(-base.getAspectRatio() + 0.1, 0.85),
                     scale=0.04,
                     align=TextNode.ALeft,
                     fg=(1, 1, 1, 1))
        OnscreenText(text='Metallic',
                     pos=(-base.getAspectRatio() + 0.1, 0.75),
                     scale=0.04,
                     align=TextNode.ALeft,
                     fg=(1, 1, 1, 1))
        OnscreenText(text='Roughness',
                     pos=(-base.getAspectRatio() + 0.1, 0.65),
                     scale=0.04,
                     align=TextNode.ALeft,
                     fg=(1, 1, 1, 1))

        self.specSlider = DirectSlider(range=(0, 100),
                                       value=50,
                                       pageSize=3,
                                       command=self.setSpecular,
                                       scale=(0.6, 0.5, 0.2),
                                       pos=(-base.getAspectRatio() + 0.7, 0,
                                            0.82))
        self.metSlider = DirectSlider(range=(0, 100),
                                      value=50,
                                      pageSize=3,
                                      command=self.setMetallic,
                                      scale=(0.6, 0.5, 0.2),
                                      pos=(-base.getAspectRatio() + 0.7, 0,
                                           0.72))
        self.roughSlider = DirectSlider(range=(0, 100),
                                        value=50,
                                        pageSize=3,
                                        command=self.setRoughness,
                                        scale=(0.6, 0.5, 0.2),
                                        pos=(-base.getAspectRatio() + 0.7, 0,
                                             0.62))

        # Set initial values
        self.setSpecular()
        self.setMetallic()
        self.setRoughness()
Esempio n. 11
0
    def __init__(self, parent: DirectFrame, text: str, value: float,
                 slider_edit_callback: Callable[['ColourChannel', float],
                                                None],
                 entry_edit_callback: Callable[['ColourChannel', float], None],
                 mouse1_press_callbacks: List[Callable[[], None]]):
        self.__frame = DirectFrame(parent=parent)
        self.__slider_edit_callback = slider_edit_callback
        self.__entry_edit_callback = entry_edit_callback

        self.__label = DirectLabel(parent=self.__frame,
                                   text=text,
                                   text_fg=WHITE,
                                   text_bg=WINDOW_BG_COLOUR,
                                   pos=(-0.5, 0.0, 0.0),
                                   scale=(0.1, 1.0, 0.1))

        self.__slider = DirectSlider(parent=self.__frame,
                                     orientation=DGG.HORIZONTAL,
                                     borderWidth=(0.0, 0.0),
                                     frameColor=WIDGET_BG_COLOUR,
                                     frameSize=(-1.0, 1.0, -0.4, 0.4),
                                     thumb_frameSize=(-0.075, 0.075, -0.2,
                                                      0.2),
                                     value=value,
                                     pos=(0.05, 0.0, 0.0255),
                                     scale=(0.45, 1.0, 0.5))

        self.__entry_hovered = False
        mouse1_press_callbacks.append(self.__entry_mouse_click_callback)
        self.__entry = DirectEntry(parent=self.__frame,
                                   frameColor=WIDGET_BG_COLOUR,
                                   text_fg=WHITE,
                                   initialText=str(value),
                                   scale=0.1,
                                   width=3,
                                   suppressKeys=True,
                                   pos=(0.55, 0.0, -0.01105))
        self.__entry.bind(DGG.EXIT, self.__entry_exit_callback)
        self.__entry.bind(DGG.ENTER, self.__entry_enter_callback)
        self.__entry.bind(DGG.B1PRESS, self.__entry_mouse_click_callback)
        self.accept("mouse1", self.__entry_mouse_click_callback)

        self.__disable_frame_overlay = DirectButton(parent=self.__frame,
                                                    frameColor=TRANSPARENT,
                                                    borderWidth=(0.0, 0.0),
                                                    frameSize=(-0.6, 0.9, -0.2,
                                                               0.2),
                                                    suppressMouse=True)
        self.__disable_frame_overlay.hide()
        self.__enabled = True

        self.__set_callbacks()
Esempio n. 12
0
    def make_slider(self, parent, pos: tuple, value, command=None):
        """Get slider of default format with provided args."""
        command = command or (lambda *args, **kwargs: None)

        slider = DirectSlider(
            command=command,
            pos=pos,
            scale=(256, 1, 128),
            value=value,
            parent=parent,
            relief=DGG.FLAT,
        )

        return slider
Esempio n. 13
0
    def __init__(self):
        tsteps = 10  # this is really molecules
        npoints = 999  # this is realy timesteps
        self.slider = DirectSlider(range=(0, 1),
                                   value=0,
                                   pageSize=1,
                                   thumb_frameSize=(0, .04, -.02, .02),
                                   command=self.t_set)
        self.slider.setPos((0, 0, -.9))

        data = np.cumsum(np.random.randint(-1, 2, (tsteps, npoints, 3)),
                         axis=1)
        data2 = [data[:, i, :] for i in range(len(data[0]))]
        #embed()
        ctup = np.random.rand(tsteps, 4)
        tm1 = [
            treeMe(None, d, np.array(['%s' % uuid4() for _ in d]),
                   np.ones(len(d))) for d in data
        ]
        self.f1 = fourObject(make4d(data, ctup, geomType=GeomLinestrips), tm1)
        sc1 = lambda: self.set_selected(self.f1)
        self.f1.coll_parent.setPythonTag('selection_callbacks', [sc1])
        self.set_selected(self.f1)

        tm2 = [
            treeMe(None, d, np.array(['%s' % uuid4() for _ in d]),
                   np.ones(len(d))) for d in data2
        ]
        self.f2 = fourObject(make4d(data2, ctup), tm2)
        self.f2.set_size(3)
        self.f2.stash()
        sc2 = lambda: self.set_selected(self.f2)
        self.f2.coll_parent.setPythonTag('selection_callbacks', [sc2])

        # TODO make clicking not on the button set the slider position?
        self.accept('s', self.set_selected, [self.f2])
Esempio n. 14
0
 def create_slider_entry(self, frame, param, component=None):
     if component is not None:
         scaled_value = param.get_param_component(component, scale=True)
     else:
         scaled_value = param.get_param(scale=True)
     hsizer = Sizer("horizontal")
     slider = DirectSlider(parent=frame,
                           scale=(self.font_size * 16, 1,
                                  self.font_size * 6),
                           value=scaled_value,
                           range=param.get_range(scale=True),
                           suppressKeys=1,
                           command=self.do_update_slider)
     widget = SizerWidget(slider)
     hsizer.add(widget,
                alignments=("expand", "center"),
                borders=self.borders)
     widget = self.create_spin_entry(frame, param, slider, component)
     hsizer.add(widget, alignments=("min", "center"), borders=self.borders)
     slider['extraArgs'] = [slider, widget.dgui_obj, param, component]
     return hsizer
Esempio n. 15
0
class MenuOptions(Menu):

    def __init__(self, _engine):
        """
        This function will initialise the main screen of the options
        and prepare the tabs with the various settings
        """
        Menu.__init__(self)

        # Engine
        self.engine = _engine

        self.initGeneralTab()
        self.initControlTab()

        self.currentTab = [0]

        self.tabGroup = [
            DirectRadioButton(
                text = _("General"),
                variable = self.currentTab,
                value = [0],
                scale = 0.05,
                pos = (-0.6, 0, 0.65),
                command = self.showGeneralTab),
            DirectRadioButton(
                text = _("Controls"),
                variable = self.currentTab,
                value = [1],
                scale = 0.05,
                pos = (0.6, 0, 0.65),
                command = self.showControlTab)
            ]

        for tab in self.tabGroup:
            tab.reparentTo(self.frameMain)
            tab.setOthers(self.tabGroup)

        # set the text of all GUI elements
        self.setText()

        self.hideBase()

    def initGeneralTab(self):
        """
        This function will set up the content of the
        general tab
        """
        self.frameGeneral = DirectFrame(
            # size of the frame
            frameSize = (base.a2dLeft, base.a2dRight,
                         -0.6, 0.6),
            # position of the frame
            pos = (0, 0, 0),
            # tramsparent bg color
            frameColor = (0, 0, 0, 0.5))

        yPos = 0.45
        shiftY = 0.25

        self.lblLanguage = DirectLabel(
            text = _("Language"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.cmbLanguage = DirectOptionMenu(
            text = "languages",
            scale = 0.15,
            pos = (base.a2dRight - 1.5, 0, 0.45),
            items = ["Deutsch","English","русский", "français"],
            initialitem = 0,
            highlightColor = (0.65,0.65,0.65,1),
            #text_font = self.defaultFontRegular,
            #item_text_font = self.defaultFontRegular,
            command = self.cmbLanguage_SelectionChanged)

        yPos -= shiftY

        self.lblResolution = DirectLabel(
            text = _("Screen resolution"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        # get the display resolutions
        di = base.pipe.getDisplayInformation()
        sizes = []
        for index in range(di.getTotalDisplayModes()):
            tmptext = "{0}x{1}".format(
                di.getDisplayModeWidth(index),
                di.getDisplayModeHeight(index))
            if not tmptext in sizes:
                sizes.append(tmptext)

        self.cmbResolution = DirectOptionMenu(
            text = "resolutions",
            scale = 0.15,
            pos = (base.a2dRight - 1.5, 0, yPos),
            items = sizes,
            initialitem = 0,
            highlightColor = (0.65, 0.65, 0.65, 1),
            #text_font = self.defaultFontRegular,
            #item_text_font = self.defaultFontRegular,
            command = self.cmbResolution_SelectionChanged)

        yPos -= shiftY

        self.lblGraphicQuality = DirectLabel(
            text = _("Graphic quality"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.graphicqualityTextMap = {
            0:_("Low"),
            1:_("Medium"),
            2:_("High")}
        self.sliderGraphicQuality = DirectSlider(
            scale = 0.5,
            pos = (base.a2dRight - 1, 0, yPos + 0.05),
            range = (0,2),
            scrollSize = 1,
            text = self.graphicqualityTextMap[self.engine.settings.graphicquality],
            text_scale = 0.25,
            text_align = TextNode.ALeft,
            text_pos = (1.1, -0.1),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            value = self.engine.settings.graphicquality,
            command = self.sliderGraphicQuality_ValueChanged)

        yPos -= shiftY

        self.lblVolume = DirectLabel(
            text = _("Volume"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.sliderVolume = DirectSlider(
            scale = 0.5,
            pos = (base.a2dRight - 1, 0, yPos + 0.05),
            range = (0,1),
            scrollSize = 0.01,
            text = str(int(self.engine.settings.volume * 100)) + "%",
            text_scale = 0.25,
            text_align = TextNode.ALeft,
            text_pos = (1.1, -0.1),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            value = self.engine.settings.volume,
            command = self.sliderVolume_ValueChanged)

        yPos -= shiftY

        self.lblVolumeMute = DirectLabel(
            text = _("Mute"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.cbVolumeMute = DirectCheckBox(
            text = "X",
            pos = (base.a2dRight - 1, 0, yPos),
            scale = (0.25, 0.25, 0.25),
            command = self.cbVolumeMute_CheckedChanged,
            rolloverSound = None,
            clickSound = None,
            relief = 0,
            pressEffect = False,
            #frameColor = (0,0,0,0),
            checkedImage = "gui/buttons/options/SoundSwitch_off.png",
            uncheckedImage = "gui/buttons/options/SoundSwitch_on.png"
            )
        self.cbVolumeMute.setTransparency(1)
        self.cbVolumeMute.setImage()
        self.cbVolumeMute["image_scale"] = 0.25
        self.cbVolumeMute["text"] = ""

        self.createBackButton(self.btnBack_Click)

        self.lblLanguage.reparentTo(self.frameGeneral)
        self.cmbLanguage.reparentTo(self.frameGeneral)
        self.lblResolution.reparentTo(self.frameGeneral)
        self.cmbResolution.reparentTo(self.frameGeneral)
        self.lblGraphicQuality.reparentTo(self.frameGeneral)
        self.sliderGraphicQuality.reparentTo(self.frameGeneral)
        self.lblVolume.reparentTo(self.frameGeneral)
        self.sliderVolume.reparentTo(self.frameGeneral)
        self.lblVolumeMute.reparentTo(self.frameGeneral)
        self.cbVolumeMute.reparentTo(self.frameGeneral)

        self.frameGeneral.reparentTo(self.frameMain)

        self.accept("LanguageChanged", self.setText)

    def initControlTab(self):
        """
        This function will set up the content of the
        control tab
        """
        self.frameControl = DirectFrame(
            # size of the frame
            frameSize = (base.a2dLeft, base.a2dRight,
                         -0.6, 0.6),
            # position of the frame
            pos = (0, 0, 0),
            # tramsparent bg color
            frameColor = (0, 0, 0, 0.5))

        numItemsVisible = 9
        itemHeight = 0.10

        # the list field for the keyboard maping to the actions
        self.controlsList = DirectScrolledList(
            decButton_pos= (0, 0, -0.05),
            decButton_text = _("up"),
            decButton_text_scale = 0.04,
            decButton_borderWidth = (0.005, 0.005),

            incButton_pos= (0, 0, -1.05),
            incButton_text = _("down"),
            incButton_text_scale = 0.04,
            incButton_borderWidth = (0.005, 0.005),

            frameSize = (-1, 1, -1.1, 0.0),
            frameColor = (0,0,0,0.5),
            pos = (0, 0, 0.6),
            numItemsVisible = numItemsVisible,
            forceHeight = itemHeight,
            itemFrame_frameSize = (-0.9, 0.9, -0.9, 0),
            itemFrame_pos = (0, 0, -0.1),
            )

        self.fillControlsList()

        self.controlsList.reparentTo(self.frameControl)
        self.frameControl.reparentTo(self.frameMain)

    def fillControlsList(self):
        for key, value in sorted(self.engine.settings.playerKeys.items()):
            # the base frame of any item in the list
            itemFrame = DirectFrame(
                frameSize = (-0.9, 0.9, -0.09, 0),
                frameColor = (0, 1, 0, 0))

            def changeKey(key, value):
                # all possible keyboard keys to set for a specific action
                keyboard = [
                    "escape",
                    "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10",
                    "f11", "f12",

                    "print_screen", "scroll_lock", "pause", "num_lock",
                    "insert", "delete", "home", "end", "page_up", "page_down",

                    "tab", "caps_lock", "shift", "rcontrol", "lcontrol", "ralt",
                    "lalt", "space", "backspace", "enter",

                    "arrow_left", "arrow_up", "arrow_down", "arrow_right",

                    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
                    "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x",
                    "y", "z",

                    "ä", "ö", "ü",

                    ",", ";", ".", ":", "_", "-", "#", "'", "+", "*", "~", "'",
                    "`", "!", "\"", "§", "$", "%", "&", "/", "(", ")", "=", "?",
                    "{", "}", "[", "]", "\\", "^", "°"
                    ]

                def setKey(arg):
                    """
                    This function will set the chosen key for the given action
                    """
                    # ignore all keyboard inputs again
                    for keyboardKey in keyboard:
                        self.ignore(keyboardKey)
                    if arg == 1:
                        # if the dialog was closed with OK
                        # set the settings to the new value
                        self.engine.settings.playerKeys[key][0] = self.selectedKey
                        if len(self.engine.settings.playerKeys[key]) > 1:
                            # just set the run key value if it is possible
                            newKey = self.engine.settings.playerKeys["run"][0] + "-" + self.selectedKey
                            self.engine.settings.playerKeys[key][1] = newKey
                    # refresh the controls list
                    self.controlsList.removeAllItems()
                    self.fillControlsList()
                    # finaly close the dialog
                    self.keySelectDialog.hide()
                    self.keySelectDialog = None

                # this variable will store the selected key for the given action
                self.selectedKey = value[0]
                def setSelectedKey(selkey):
                    """
                    set the pressed key as the selected one and actualise the text
                    on the dialog
                    """
                    self.selectedKey = selkey
                    self.keySelectDialog["text"] = "{0}: {1}".format(key, self.selectedKey)

                # accept all keyboard keys
                for keyboardKey in keyboard:
                    self.accept(
                        keyboardKey,
                        setSelectedKey,
                        [keyboardKey])

                # set up a dialog wich will ask for the new key for the chosen action
                self.keySelectDialog = OkCancelDialog(
                    dialogName = "OkCancelDialog",
                    text = "{0}: {1}".format(key, value[0]),
                    fadeScreen = 1,
                    command = setKey
                    )
                # show the dialog
                self.keySelectDialog.show()

            # add the change button to change the key of the action
            itemBtnChange = DirectButton(
                text = _("change"),
                scale = 0.05,
                pos = (0.5, 0, -0.05),
                command = changeKey,
                extraArgs = [key, value]
                )
            itemBtnChange.reparentTo(itemFrame)
            # add the label wich will show the name and key of the action
            itemText = DirectLabel(
                text = "{0} - {1}".format(key, value[0]),
                text_scale = 0.06,
                text_align = TextNode.ALeft,
                pos = (-0.88, 0, -0.06))
            itemText.reparentTo(itemFrame)

            # finaly add the item to the list
            self.controlsList.addItem(itemFrame)


    def show(self):
        self.setText()
        self.showBase()

    def showGeneralTab(self):
        # set the selected language in the textbox
        if self.engine.settings.selectedLanguage == "de-DE":
            self.cmbLanguage.set(0, False)
        elif self.engine.settings.selectedLanguage == "ru-RU":
            self.cmbLanguage.set(2, False)
        elif self.engine.settings.selectedLanguage == "fr-FR":
            self.cmbLanguage.set(3, False)
        else:
            self.cmbLanguage.set(1, False)


        res = str(self.engine.settings.windowSize[0]) + "x" + str(self.engine.settings.windowSize[1])
        i = 0
        for item in self.cmbResolution["items"]:
            if item == res:
                self.cmbResolution.set(i, False)
            i += 1

        self.sliderGraphicQuality["value"] = self.engine.settings.graphicquality

        self.sliderVolume["value"] = self.engine.settings.volume

        #self.cbVolumeMute["indicatorValue"] = settings.muted
        self.cbVolumeMute["isChecked"] = not self.engine.settings.muted
        self.cbVolumeMute.commandFunc(None)
        #self.cbVolumeMute.setIndicatorValue()

        self.frameGeneral.show()
        self.hideControlTab()

    def showControlTab(self):
        self.frameControl.show()
        self.hideGeneralTab()

    def hide(self):
        self.hideBase()

    def hideGeneralTab(self):
        self.frameGeneral.hide()

    def hideControlTab(self):
        self.frameControl.hide()

    def setText(self):
        self.title["text"] = _("Options")
        self.btnBack["text"] = _("Back")
        self.lblLanguage["text"] = _("Language")
        self.lblResolution["text"] = _("Screen resolution")
        self.lblGraphicQuality["text"] = _("Graphic quality")
        self.graphicqualityTextMap = {
            0:_("Low"),
            1:_("Medium"),
            2:_("High")}
        self.sliderGraphicQuality["text"] = self.graphicqualityTextMap[
            self.engine.settings.graphicquality]
        self.lblVolume["text"] = _("Volume")
        self.lblVolumeMute["text"] = _("Mute")


    def cmbLanguage_SelectionChanged(self, arg):
        # TODO: get available languages and maping from language class!
        if arg == "Deutsch":
            self.engine.lng.changeLanguage("de-DE")
            self.engine.settings.selectedLanguage = "de-DE"
        elif arg == "русский":
            self.engine.lng.changeLanguage("ru-RU")
            self.engine.settings.selectedLanguage = "ru-RU"
        elif arg == "français":
            self.engine.lng.changeLanguage("fr-FR")
            self.engine.settings.selectedLanguage = "fr-FR"
        else:
            self.engine.lng.changeLanguage("en-US")
            self.engine.settings.selectedLanguage = "en-US"

    def cmbResolution_SelectionChanged(self, arg):
        resx = int(arg.split("x")[0])
        resy = int(arg.split("x")[1])
        self.engine.settings.windowSize = [resx, resy]
        self.engine.graphicMgr.setResolution(resx, resy)

    def sliderGraphicQuality_ValueChanged(self):
        val = int(round(self.sliderGraphicQuality["value"], 0))
        self.sliderGraphicQuality["text"] = self.graphicqualityTextMap[val]
        if val != self.engine.settings.graphicquality:
            self.engine.settings.graphicquality = val
            self.engine.graphicMgr.setGraphicQuality(self.engine.settings.graphicquality)

    def sliderVolume_ValueChanged(self):
        val = round(self.sliderVolume["value"], 2)
        self.sliderVolume["text"] = str(int(val * 100)) + "%"
        self.engine.settings.volume = val
        self.engine.audioMgr.setVolume(self.engine.settings.volume)

    def cbVolumeMute_CheckedChanged(self, checked):
        self.cbVolumeMute["image_scale"] = 0.35
        self.cbVolumeMute["image_pos"] = (0.05,0,0.25)
        self.engine.settings.muted = bool(checked)
        self.engine.audioMgr.mute(self.engine.settings.muted)

    def btnBack_Click(self):
        base.messenger.send("OptMenu_back")
Esempio n. 16
0
    def setup(self):
        if hasattr(self, 'mainFrame'):
            self.mainFrame.destroy()

        self.mainFrame = DirectFrame(parent=self, relief=None)

        def setVisibility():
            value = self.visSlider['value']
            self.setColorScale(Vec4(1, 1, 1, value))

        self.visSlider = DirectSlider(guiId='visSlider',
                                      parent=self.mainFrame,
                                      scale=0.40000000000000002,
                                      thumb_relief=DGG.FLAT,
                                      thumb_color=(0.25, 1.0, 0.25, 1),
                                      pos=(0.40000000000000002, 0,
                                           -0.84999999999999998),
                                      text='Visibility',
                                      text_scale=0.20000000000000001,
                                      text_pos=(0, 0.10000000000000001, 0),
                                      text_bg=(0.80000000000000004,
                                               0.80000000000000004,
                                               0.80000000000000004, 1),
                                      value=1.0,
                                      command=setVisibility)
        self.visSlider.getChild(0).setTransparency(0)
        self.camFrame = DirectFrame(
            guiId='camFrame',
            parent=self.mainFrame,
            relief=DGG.RIDGE,
            frameSize=(0.0, 0.80000000000000004, 0.0, 0.32000000000000001),
            frameColor=(1, 1, 0.75, 1),
            borderWidth=(0.0050000000000000001, 0.0050000000000000001),
            pos=(0, 0, 0.59999999999999998),
            text='Camera',
            text_fg=(0, 0, 0, 1),
            text_scale=0.050000000000000003,
            text_pos=(0.10000000000000001, 0.26000000000000001, 0))
        self.camSlider = RangeSlider(guiId='zoom',
                                     label='Zoom (Y-axis)',
                                     range=(-0.75, 0.25),
                                     value=0,
                                     parent=self.camFrame,
                                     pos=(0.39500000000000002, 0,
                                          0.070000000000000007))
        self.worldFrame = DirectFrame(
            guiId='worldFrame',
            parent=self.mainFrame,
            relief=DGG.RIDGE,
            frameSize=(0.0, 0.80000000000000004, -0.55000000000000004, 0.5),
            frameColor=(1, 0.75, 0.75, 1),
            borderWidth=(0.0050000000000000001, 0.0050000000000000001),
            pos=(0.0, 0, 0),
            text='World',
            text_fg=(0, 0, 0, 1),
            text_scale=0.050000000000000003,
            text_pos=(0.10000000000000001, 0.42999999999999999, 0))
        self.worldPSlider = RangeSlider(guiId='worldP',
                                        label='World P',
                                        range=(-90, 0),
                                        value=0.0,
                                        parent=self.worldFrame,
                                        pos=(0.39500000000000002, 0,
                                             0.23999999999999999))
        self.worldDecorScaleSlider = RangeSlider(guiId='worldP',
                                                 label='World Decor Scale',
                                                 range=(0.20000000000000001,
                                                        0.29999999999999999),
                                                 value=0.25,
                                                 parent=self.worldFrame,
                                                 pos=(0.39500000000000002, 0,
                                                      0.0))
        self.finalSlider = RangeSlider(guiId='final',
                                       label='Final',
                                       range=(0, 1),
                                       value=0,
                                       parent=self.worldFrame,
                                       pos=(0.39500000000000002, 0,
                                            -0.47999999999999998))
        self.saveState0Button = DirectButton(guiId='save0Button',
                                             parent=self.mainFrame,
                                             scale=0.10000000000000001,
                                             pos=(0.20000000000000001, 0,
                                                  -0.65000000000000002),
                                             borderWidth=(0.10000000000000001,
                                                          0.10000000000000001),
                                             text='save pt0')
        self.saveState1Button = DirectButton(guiId='save1Button',
                                             parent=self.mainFrame,
                                             scale=0.10000000000000001,
                                             pos=(0.59999999999999998, 0,
                                                  -0.65000000000000002),
                                             borderWidth=(0.10000000000000001,
                                                          0.10000000000000001),
                                             text='save pt1')
Esempio n. 17
0
    def __init__(self):
        """Default constructor"""
        # create a main frame as big as the window
        self.frameMain = DirectFrame(
            # set framesize the same size as the window
            frameSize=(base.a2dLeft, base.a2dRight, base.a2dTop,
                       base.a2dBottom),
            image="LogoTextGlow.png",
            image_scale=(1.06 / 2.0, 1, 0.7 / 2.0),
            image_pos=(0, 0, 0.7),
            # position center
            pos=(0, 0, 0),
            # set tramsparent background color
            frameColor=(0, 0, 0, 0))
        self.frameMain.setTransparency(1)
        self.frameMain.setBin("fixed", 100)

        sliderscale = 0.5
        buttonScale = 0.25
        textscale = 0.1
        checkboxscale = 0.05
        left = -0.5
        right = 0.5

        self.sliderTextspeed = DirectSlider(
            scale=sliderscale,
            pos=(left, 0, 0.2),
            range=(0.2, 0.01),
            scrollSize=0.01,
            text=_("Textspeed %0.1f%%") % (base.textWriteSpeed * 10),
            text_scale=textscale,
            text_align=TextNode.ACenter,
            text_pos=(0.0, 0.15),
            text_fg=(1, 1, 1, 1),
            thumb_frameColor=(0.65, 0.65, 0.0, 1),
            thumb_relief=DGG.FLAT,
            frameColor=(0.15, 0.15, 0.15, 1),
            value=base.textWriteSpeed,
            command=self.sliderTextspeed_ValueChanged)
        self.sliderTextspeed.reparentTo(self.frameMain)

        self.cbParticles = DirectCheckButton(
            text=_(" Enable Particles"),
            text_fg=(1, 1, 1, 1),
            text_shadow=(0, 0, 0, 0.35),
            pos=(left, 0, -0.0),
            scale=checkboxscale,
            frameColor=(0, 0, 0, 0),
            command=self.cbParticles_CheckedChanged,
            rolloverSound=None,
            clickSound=None,
            pressEffect=False,
            boxPlacement="below",
            boxBorder=0.8,
            boxRelief=DGG.FLAT,
            indicator_scale=1.5,
            indicator_text_fg=(0.65, 0.65, 0.0, 1),
            indicator_text_shadow=(0, 0, 0, 0.35),
            indicator_frameColor=(0.15, 0.15, 0.15, 1),
            indicatorValue=base.particleMgrEnabled)
        self.cbParticles.indicator['text'] = (' ', 'x')
        self.cbParticles.indicator['text_pos'] = (0, 0.1)
        #self.cbParticles.indicator.setX(self.cbParticles.indicator, -0.5)
        #self.cbParticles.indicator.setZ(self.cbParticles.indicator, -0.1)
        #self.cbParticles.setFrameSize()
        self.cbParticles.setTransparency(1)
        self.cbParticles.reparentTo(self.frameMain)

        volume = base.musicManager.getVolume()
        self.sliderVolume = DirectSlider(
            scale=sliderscale,
            pos=(left, 0, -0.35),
            range=(0, 1),
            scrollSize=0.01,
            text=_("Volume %d%%") % volume * 100,
            text_scale=textscale,
            text_align=TextNode.ACenter,
            text_pos=(.0, 0.15),
            text_fg=(1, 1, 1, 1),
            thumb_frameColor=(0.65, 0.65, 0.0, 1),
            thumb_relief=DGG.FLAT,
            frameColor=(0.15, 0.15, 0.15, 1),
            value=volume,
            command=self.sliderVolume_ValueChanged)
        self.sliderVolume.reparentTo(self.frameMain)

        self.lblControltype = DirectLabel(text=_("Control type"),
                                          text_fg=(1, 1, 1, 1),
                                          text_shadow=(0, 0, 0, 0.35),
                                          frameColor=(0, 0, 0, 0),
                                          scale=textscale / 2,
                                          pos=(right, 0, 0.27))
        self.lblControltype.setTransparency(1)
        self.lblControltype.reparentTo(self.frameMain)
        selectedControlType = 0
        if base.controlType == "MouseAndKeyboard":
            selectedControlType = 1
        self.controltype = DirectOptionMenu(
            pos=(right, 0, 0.18),
            text_fg=(1, 1, 1, 1),
            scale=0.1,
            items=[_("Keyboard"), _("Keyboard + Mouse")],
            initialitem=selectedControlType,
            frameColor=(0.15, 0.15, 0.15, 1),
            popupMarker_frameColor=(0.65, 0.65, 0.0, 1),
            popupMarker_relief=DGG.FLAT,
            highlightColor=(0.65, 0.65, 0.0, 1),
            relief=DGG.FLAT,
            command=self.controlType_Changed)
        self.controltype.reparentTo(self.frameMain)
        b = self.controltype.getBounds()
        xPos = right - ((b[1] - b[0]) / 2.0 * 0.1)
        self.controltype.setX(xPos)
        setItems(self.controltype)
        self.controltype.setItems = setItems
        self.controltype.showPopupMenu = showPopupMenu
        self.controltype.popupMarker.unbind(DGG.B1PRESS)
        self.controltype.popupMarker.bind(DGG.B1PRESS, showPopupMenu)
        self.controltype.unbind(DGG.B1PRESS)
        self.controltype.bind(DGG.B1PRESS, showPopupMenuExtra,
                              [self.controltype])

        isChecked = not base.AppHasAudioFocus
        img = None
        if base.AppHasAudioFocus:
            img = "AudioSwitch_on.png"
        else:
            img = "AudioSwitch_off.png"
        self.cbVolumeMute = DirectCheckBox(
            text=_("Mute Audio"),
            text_scale=0.5,
            text_align=TextNode.ACenter,
            text_pos=(0.0, 0.65),
            text_fg=(1, 1, 1, 1),
            pos=(right, 0, -0.35),
            scale=0.21 / 2.0,
            command=self.cbVolumeMute_CheckedChanged,
            rolloverSound=None,
            clickSound=None,
            relief=None,
            pressEffect=False,
            isChecked=isChecked,
            image=img,
            image_scale=0.5,
            checkedImage="AudioSwitch_off.png",
            uncheckedImage="AudioSwitch_on.png")
        self.cbVolumeMute.setTransparency(1)
        self.cbVolumeMute.setImage()
        self.cbVolumeMute.reparentTo(self.frameMain)

        sensitivity = base.mouseSensitivity
        self.sliderSensitivity = DirectSlider(
            scale=sliderscale,
            pos=(right, 0, -0.075),
            range=(0.5, 2),
            scrollSize=0.01,
            text=_("Mouse Sensitivity %0.1fx") % sensitivity,
            text_scale=textscale,
            text_align=TextNode.ACenter,
            text_pos=(.0, 0.15),
            text_fg=(1, 1, 1, 1),
            thumb_frameColor=(0.65, 0.65, 0.0, 1),
            thumb_relief=DGG.FLAT,
            frameColor=(0.15, 0.15, 0.15, 1),
            value=sensitivity,
            command=self.sliderSensitivity_ValueChanged)
        self.sliderSensitivity.reparentTo(self.frameMain)
        if base.controlType == "Gamepad":
            self.sliderSensitivity.hide()

        # create the back button
        self.btnBack = DirectButton(
            scale=buttonScale,
            # position on the window
            pos=(0, 0, base.a2dBottom + 0.15),
            frameColor=(0, 0, 0, 0),
            # text properties
            text=_("Back"),
            text_scale=0.5,
            text_fg=(1, 1, 1, 1),
            text_pos=(0.0, -0.15),
            text_shadow=(0, 0, 0, 0.35),
            text_shadowOffset=(-0.05, -0.05),
            # sounds that should be played
            rolloverSound=None,
            clickSound=None,
            pressEffect=False,
            relief=None,
            # the event which is thrown on clickSound
            command=lambda: base.messenger.send("options_back"))
        self.btnBack.setTransparency(1)
        self.btnBack.reparentTo(self.frameMain)

        self.hide()
Esempio n. 18
0
class MapConfig(DirectFrame):

    def __init__(self, *args, **kwargs):
        kwargs['suppressMouse'] = 0
        super(self.__class__, self).__init__(*args, **kwargs)
        self.initialiseoptions(self.__class__)
        self.setTransparency(1)
        self.setup()

    def setup(self):
        if hasattr(self, 'mainFrame'):
            self.mainFrame.destroy()
        self.mainFrame = DirectFrame(parent=self, relief=None)

        def setVisibility():
            value = self.visSlider['value']
            self.setColorScale(Vec4(1, 1, 1, value))

        self.visSlider = DirectSlider(guiId='visSlider', parent=self.mainFrame, scale=0.4, thumb_relief=DGG.FLAT, thumb_color=(0.25,
                                                                                                                               1.0,
                                                                                                                               0.25,
                                                                                                                               1), pos=(0.4, 0, -0.85), text='Visibility', text_scale=0.2, text_pos=(0,
                                                                                                                                                                                                     0.1,
                                                                                                                                                                                                     0), text_bg=(0.8,
                                                                                                                                                                                                                  0.8,
                                                                                                                                                                                                                  0.8,
                                                                                                                                                                                                                  1), value=1.0, command=setVisibility)
        self.visSlider.getChild(0).setTransparency(0)
        self.camFrame = DirectFrame(guiId='camFrame', parent=self.mainFrame, relief=DGG.RIDGE, frameSize=(0.0,
                                                                                                          0.8,
                                                                                                          0.0,
                                                                                                          0.32), frameColor=(1,
                                                                                                                             1,
                                                                                                                             0.75,
                                                                                                                             1), borderWidth=(0.005,
                                                                                                                                              0.005), pos=(0,
                                                                                                                                                           0,
                                                                                                                                                           0.6), text='Camera', text_fg=(0,
                                                                                                                                                                                         0,
                                                                                                                                                                                         0,
                                                                                                                                                                                         1), text_scale=0.05, text_pos=(0.1,
                                                                                                                                                                                                                        0.26,
                                                                                                                                                                                                                        0))
        self.camSlider = RangeSlider(guiId='zoom', label='Zoom (Y-axis)', range=(-0.75, 0.25), value=0, parent=self.camFrame, pos=(0.395,
                                                                                                                                   0,
                                                                                                                                   0.07))
        self.worldFrame = DirectFrame(guiId='worldFrame', parent=self.mainFrame, relief=DGG.RIDGE, frameSize=(0.0, 0.8, -0.55, 0.5), frameColor=(1,
                                                                                                                                                 0.75,
                                                                                                                                                 0.75,
                                                                                                                                                 1), borderWidth=(0.005,
                                                                                                                                                                  0.005), pos=(0.0,
                                                                                                                                                                               0,
                                                                                                                                                                               0), text='World', text_fg=(0,
                                                                                                                                                                                                          0,
                                                                                                                                                                                                          0,
                                                                                                                                                                                                          1), text_scale=0.05, text_pos=(0.1,
                                                                                                                                                                                                                                         0.43,
                                                                                                                                                                                                                                         0))
        self.worldPSlider = RangeSlider(guiId='worldP', label='World P', range=(-90,
                                                                                0), value=0.0, parent=self.worldFrame, pos=(0.395,
                                                                                                                            0,
                                                                                                                            0.24))
        self.worldDecorScaleSlider = RangeSlider(guiId='worldP', label='World Decor Scale', range=(0.2,
                                                                                                   0.3), value=0.25, parent=self.worldFrame, pos=(0.395,
                                                                                                                                                  0,
                                                                                                                                                  0.0))
        self.finalSlider = RangeSlider(guiId='final', label='Final', range=(0, 1), value=0, parent=self.worldFrame, pos=(0.395, 0, -0.48))
        self.saveState0Button = DirectButton(guiId='save0Button', parent=self.mainFrame, scale=0.1, pos=(0.2, 0, -0.65), borderWidth=(0.1,
                                                                                                                                      0.1), text='save pt0')
        self.saveState1Button = DirectButton(guiId='save1Button', parent=self.mainFrame, scale=0.1, pos=(0.6, 0, -0.65), borderWidth=(0.1,
                                                                                                                                      0.1), text='save pt1')
        return
Esempio n. 19
0
    def __init__(self):
        """Default constructor"""
        # create a main frame as big as the window
        self.frameMain = DirectFrame(
            # set framesize the same size as the window
            frameSize = (base.a2dLeft, base.a2dRight,
                         base.a2dTop, base.a2dBottom),
            image = "LogoTextGlow.png",
            image_scale = (1.06/2.0, 1, 0.7/2.0),
            image_pos = (0, 0, 0.7),
            # position center
            pos = (0, 0, 0),
            # set tramsparent background color
            frameColor = (0, 0, 0, 0))
        self.frameMain.setTransparency(1)
        self.frameMain.setBin("fixed", 100)

        sliderscale = 0.5
        buttonScale = 0.25
        textscale = 0.1
        checkboxscale = 0.05
        left = -0.5
        right = 0.5

        self.sliderTextspeed = DirectSlider(
            scale = sliderscale,
            pos = (left, 0, 0.2),
            range = (0.2,0.01),
            scrollSize = 0.01,
            text = _("Textspeed %0.1f%%")%(base.textWriteSpeed * 10),
            text_scale = textscale,
            text_align = TextNode.ACenter,
            text_pos = (0.0, 0.15),
            text_fg = (1,1,1,1),
            thumb_frameColor = (0.65, 0.65, 0.0, 1),
            thumb_relief = DGG.FLAT,
            frameColor = (0.15, 0.15, 0.15, 1),
            value = base.textWriteSpeed,
            command = self.sliderTextspeed_ValueChanged)
        self.sliderTextspeed.reparentTo(self.frameMain)

        self.cbParticles = DirectCheckButton(
            text = _(" Enable Particles"),
            text_fg = (1, 1, 1, 1),
            text_shadow = (0, 0, 0, 0.35),
            pos = (left, 0, -0.0),
            scale = checkboxscale,
            frameColor = (0,0,0,0),
            command = self.cbParticles_CheckedChanged,
            rolloverSound = None,
            clickSound = None,
            pressEffect = False,
            boxPlacement = "below",
            boxBorder = 0.8,
            boxRelief = DGG.FLAT,
            indicator_scale = 1.5,
            indicator_text_fg = (0.65, 0.65, 0.0, 1),
            indicator_text_shadow = (0, 0, 0, 0.35),
            indicator_frameColor = (0.15, 0.15, 0.15, 1),
            indicatorValue = base.particleMgrEnabled
            )
        self.cbParticles.indicator['text'] = (' ', 'x')
        self.cbParticles.indicator['text_pos'] = (0, 0.1)
        #self.cbParticles.indicator.setX(self.cbParticles.indicator, -0.5)
        #self.cbParticles.indicator.setZ(self.cbParticles.indicator, -0.1)
        #self.cbParticles.setFrameSize()
        self.cbParticles.setTransparency(1)
        self.cbParticles.reparentTo(self.frameMain)

        volume = base.musicManager.getVolume()
        self.sliderVolume = DirectSlider(
            scale = sliderscale,
            pos = (left, 0, -0.35),
            range = (0,1),
            scrollSize = 0.01,
            text = _("Volume %d%%")%volume*100,
            text_scale = textscale,
            text_align = TextNode.ACenter,
            text_pos = (.0, 0.15),
            text_fg = (1,1,1,1),
            thumb_frameColor = (0.65, 0.65, 0.0, 1),
            thumb_relief = DGG.FLAT,
            frameColor = (0.15, 0.15, 0.15, 1),
            value = volume,
            command = self.sliderVolume_ValueChanged)
        self.sliderVolume.reparentTo(self.frameMain)

        self.lblControltype = DirectLabel(
            text = _("Control type"),
            text_fg = (1, 1, 1, 1),
            text_shadow = (0, 0, 0, 0.35),
            frameColor = (0, 0, 0, 0),
            scale = textscale/2,
            pos = (right, 0, 0.27))
        self.lblControltype.setTransparency(1)
        self.lblControltype.reparentTo(self.frameMain)
        selectedControlType = 0
        if base.controlType == "MouseAndKeyboard":
            selectedControlType = 1
        self.controltype = DirectOptionMenu(
            pos = (right, 0, 0.18),
            text_fg = (1, 1, 1, 1),
            scale = 0.1,
            items = [_("Keyboard"),_("Keyboard + Mouse")],
            initialitem = selectedControlType,
            frameColor = (0.15, 0.15, 0.15, 1),
            popupMarker_frameColor = (0.65, 0.65, 0.0, 1),
            popupMarker_relief = DGG.FLAT,
            highlightColor = (0.65, 0.65, 0.0, 1),
            relief = DGG.FLAT,
            command=self.controlType_Changed)
        self.controltype.reparentTo(self.frameMain)
        b = self.controltype.getBounds()
        xPos = right - ((b[1] - b[0]) / 2.0 * 0.1)
        self.controltype.setX(xPos)
        setItems(self.controltype)
        self.controltype.setItems = setItems
        self.controltype.showPopupMenu = showPopupMenu
        self.controltype.popupMarker.unbind(DGG.B1PRESS)
        self.controltype.popupMarker.bind(DGG.B1PRESS, showPopupMenu)
        self.controltype.unbind(DGG.B1PRESS)
        self.controltype.bind(DGG.B1PRESS, showPopupMenuExtra, [self.controltype])

        isChecked = not base.AppHasAudioFocus
        img = None
        if base.AppHasAudioFocus:
            img = "AudioSwitch_on.png"
        else:
            img = "AudioSwitch_off.png"
        self.cbVolumeMute = DirectCheckBox(
            text = _("Mute Audio"),
            text_scale = 0.5,
            text_align = TextNode.ACenter,
            text_pos = (0.0, 0.65),
            text_fg = (1,1,1,1),
            pos = (right, 0, -0.35),
            scale = 0.21/2.0,
            command = self.cbVolumeMute_CheckedChanged,
            rolloverSound = None,
            clickSound = None,
            relief = None,
            pressEffect = False,
            isChecked = isChecked,
            image = img,
            image_scale = 0.5,
            checkedImage = "AudioSwitch_off.png",
            uncheckedImage = "AudioSwitch_on.png")
        self.cbVolumeMute.setTransparency(1)
        self.cbVolumeMute.setImage()
        self.cbVolumeMute.reparentTo(self.frameMain)

        sensitivity = base.mouseSensitivity
        self.sliderSensitivity = DirectSlider(
            scale = sliderscale,
            pos = (right, 0, -0.075),
            range = (0.5,2),
            scrollSize = 0.01,
            text = _("Mouse Sensitivity %0.1fx")%sensitivity,
            text_scale = textscale,
            text_align = TextNode.ACenter,
            text_pos = (.0, 0.15),
            text_fg = (1,1,1,1),
            thumb_frameColor = (0.65, 0.65, 0.0, 1),
            thumb_relief = DGG.FLAT,
            frameColor = (0.15, 0.15, 0.15, 1),
            value = sensitivity,
            command = self.sliderSensitivity_ValueChanged)
        self.sliderSensitivity.reparentTo(self.frameMain)
        if base.controlType == "Gamepad":
            self.sliderSensitivity.hide()

        # create the back button
        self.btnBack = DirectButton(
            scale = buttonScale,
            # position on the window
            pos = (0, 0, base.a2dBottom + 0.15),
            frameColor = (0,0,0,0),
            # text properties
            text = _("Back"),
            text_scale = 0.5,
            text_fg = (1,1,1,1),
            text_pos = (0.0, -0.15),
            text_shadow = (0, 0, 0, 0.35),
            text_shadowOffset = (-0.05, -0.05),
            # sounds that should be played
            rolloverSound = None,
            clickSound = None,
            pressEffect = False,
            relief = None,
            # the event which is thrown on clickSound
            command = lambda: base.messenger.send("options_back"))
        self.btnBack.setTransparency(1)
        self.btnBack.reparentTo(self.frameMain)

        self.hide()
Esempio n. 20
0
class do4d(DirectObject, HasKeybinds):
    def __init__(self):
        tsteps = 10  # this is really molecules
        npoints = 999  # this is realy timesteps
        self.slider = DirectSlider(range=(0, 1),
                                   value=0,
                                   pageSize=1,
                                   thumb_frameSize=(0, .04, -.02, .02),
                                   command=self.t_set)
        self.slider.setPos((0, 0, -.9))

        data = np.cumsum(np.random.randint(-1, 2, (tsteps, npoints, 3)),
                         axis=1)
        data2 = [data[:, i, :] for i in range(len(data[0]))]
        #embed()
        ctup = np.random.rand(tsteps, 4)
        tm1 = [
            treeMe(None, d, np.array(['%s' % uuid4() for _ in d]),
                   np.ones(len(d))) for d in data
        ]
        self.f1 = fourObject(make4d(data, ctup, geomType=GeomLinestrips), tm1)
        sc1 = lambda: self.set_selected(self.f1)
        self.f1.coll_parent.setPythonTag('selection_callbacks', [sc1])
        self.set_selected(self.f1)

        tm2 = [
            treeMe(None, d, np.array(['%s' % uuid4() for _ in d]),
                   np.ones(len(d))) for d in data2
        ]
        self.f2 = fourObject(make4d(data2, ctup), tm2)
        self.f2.set_size(3)
        self.f2.stash()
        sc2 = lambda: self.set_selected(self.f2)
        self.f2.coll_parent.setPythonTag('selection_callbacks', [sc2])

        # TODO make clicking not on the button set the slider position?
        self.accept('s', self.set_selected, [self.f2])

    def set_selected(self, fourObject):  # TODO type check?
        self.selected = fourObject
        self.selected.unstash()
        self.slider['range'] = (0, len(self.selected) - 1)
        self.slider['value'] = fourObject.__index__
        print('selected set to', fourObject)

    @event_callback('a')
    def t_all(self):
        if not self.selected._all:
            self.selected.show_all()
        else:
            self.selected.hide_all()

    def t_set(self):
        value = int(self.slider['value'])
        if value != self.selected.__index__:
            self.selected.goto_index(value)

    @event_callback((']', ']-repeat'))
    def t_up(self):
        #self.selected.next_index()
        self.slider['value'] = (self.slider['value'] + 1) % len(self.selected)

    @event_callback(('[', '[-repeat'))
    def t_down(self):
        #self.selected.prev_index()
        self.slider['value'] = (self.slider['value'] - 1) % len(self.selected)
Esempio n. 21
0
    def __init__(self, mesh, pm_filebuf):

        scene_members = getSceneMembers(mesh)

        base = ShowBase()

        if len(scene_members) > 1:
            print 'There is more than one geometry in the scene, so I think this is not a progressive base mesh.'
            sys.exit(1)

        rotateNode = GeomNode("rotater")
        rotatePath = render.attachNewNode(rotateNode)
        matrix = numpy.identity(4)
        if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
            r = collada.scene.RotateTransform(0, 1, 0, 90)
            matrix = r.matrix
        elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
            r = collada.scene.RotateTransform(1, 0, 0, 90)
            matrix = r.matrix
        rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))

        geom, renderstate, mat4 = scene_members[0]
        node = GeomNode("primitive")
        node.addGeom(geom)
        if renderstate is not None:
            node.setGeomState(0, renderstate)
        self.geomPath = rotatePath.attachNewNode(node)
        self.geomPath.setMat(mat4)

        wrappedNode = ensureCameraAt(self.geomPath, base.camera)
        base.disableMouse()
        attachLights(render)
        render.setShaderAuto()
        render.setTransparency(TransparencyAttrib.MDual, 1)

        base.render.analyze()
        KeyboardMovement()
        MouseDrag(wrappedNode)
        MouseScaleZoom(wrappedNode)
        ButtonUtils(wrappedNode)
        MouseCamera()

        print 'Loading pm into memory... ',
        sys.stdout.flush()
        self.pm_refinements = readPDAE(pm_filebuf)
        self.pm_index = 0
        print 'Done'

        self.slider = DirectSlider(range=(0, len(self.pm_refinements)),
                                   value=0,
                                   pageSize=len(self.pm_refinements) / 20,
                                   command=self.sliderMoved,
                                   pos=(0, 0, -.9),
                                   scale=1)
        for key, val in uiArgs.iteritems():
            self.slider.thumb[key] = val

        self.triText = OnscreenText(text="",
                                    pos=(-1, 0.85),
                                    scale=0.15,
                                    fg=(1, 0.5, 0.5, 1),
                                    align=TextNode.ALeft,
                                    mayChange=1)

        base.run()
Esempio n. 22
0
    def setup(self, node):
        colours = self.app.theme.colours

        SLIDER_PROPERTIES = {
            'range': (0, 100),
            'pageSize': 100,
            'scrollSize': 0,
            'parent': node,
            'scale': 0.5,
            'frameSize': (-0.85, 0.85, -0.08, 0.08),
            'thumb_relief': DGG.RIDGE,
        }

        TEXT_PROPERTIES = {
            'parent': node,
            'text_scale': 0.08,
            'text_fg': colours.listboxButtons,
            'text_align': TextNode.A_left,
            'relief': None,
            'textMayChange': True,
        }

        label = DirectLabel(
            text='Music volume',
            **TEXT_PROPERTIES
        )
        align(label, left=-0.85, midZ=0.25)

        self.musicSlider = DirectSlider(**SLIDER_PROPERTIES)
        align(self.musicSlider, left=-0.2, midZ=0.25)

        self.musicLabel = DirectLabel(
            text='100',
            **TEXT_PROPERTIES
        )
        align(self.musicLabel, left=0.70, midZ=0.25)

        label = DirectLabel(
            text='Enable music',
            **TEXT_PROPERTIES
        )
        align(label, left=-0.85, midZ=0.10)

        self.musicCheckbox = DirectCheckButton(
            scale=0.06,
            parent=node,
            command=self.applySettings,
        )
        align(self.musicCheckbox, left=-0.2, midZ=0.10)

        label = DirectLabel(
            text='Sound volume',
            **TEXT_PROPERTIES
        )
        align(label, left=-0.85, midZ=-0.05)

        self.soundSlider = DirectSlider(**SLIDER_PROPERTIES)
        align(self.soundSlider, left=-0.2, midZ=-0.05)

        self.soundLabel = DirectLabel(
            text='100',
            **TEXT_PROPERTIES
        )
        align(self.soundLabel, left=0.70, midZ=-0.05)

        label = DirectLabel(
            text='Enable sound',
            **TEXT_PROPERTIES
        )
        align(label, left=-0.85, midZ=-0.20)

        self.soundCheckbox = DirectCheckButton(
            scale=0.06,
            parent=node,
            command=self.applySettings,
        )
        align(self.soundCheckbox, left=-0.2, midZ=-0.20)

        BUTTON_PROPERTIES = {
            'scale': 0.04,
            'frameSize': (-5.0, 5.0, -1.0, 1.5),
            'parent': node,
        }

        button = DirectButton(
            text='Back',
            command=self.parent.showMainButtons,
            **BUTTON_PROPERTIES
        )
        align(button, right=0.87, z=-0.63)
Esempio n. 23
0
class OptionPage(StateData):
    def __init__(self, book, parentFSM):
        self.book = book
        self.parentFSM = parentFSM
        StateData.__init__(self, 'optionPageDone')
        self.fsm = ClassicFSM('OptionPage', [
            State('off', self.enterOff, self.exitOff),
            State('basePage', self.enterBasePage, self.exitBasePage),
            State('displayPage', self.enterDisplayPage, self.exitDisplayPage)
        ], 'off', 'off')
        self.fsm.enterInitialState()
        self.parentFSM.getStateNamed('optionPage').addChild(self.fsm)

    def enterOff(self):
        pass

    def exitOff(self):
        pass

    def load(self):
        StateData.load(self)

    def unload(self):
        StateData.unload(self)

    def enter(self):
        StateData.enter(self)
        self.fsm.request('basePage')

    def exit(self):
        self.fsm.request('off')
        StateData.exit(self)

    def openDisplayPage(self):
        self.fsm.request('displayPage')

    def enterDisplayPage(self):
        self.book.createPageButtons(False, False)
        self.book.setTitle('Display Options')
        dialog_gui = loader.loadModel(
            'phase_3/models/gui/dialog_box_buttons_gui.bam')
        width, height, fs, music, sfx, tex_detail, model_detail, aa, af = SettingsManager(
        ).getSettings('settings.json')
        self.width = width
        self.height = height
        self.windowType = [fs]
        self.buttons = [
            DirectRadioButton(text='Windowed',
                              variable=self.windowType,
                              value=[False],
                              scale=0.1,
                              pos=(-0.45, 0.15, 0.15)),
            DirectRadioButton(text='Fullscreen',
                              variable=self.windowType,
                              value=[True],
                              scale=0.1,
                              pos=(-0.45, -0.15, -0.15))
        ]
        for button in self.buttons:
            button.setOthers(self.buttons)

        self.resoLbl = DirectLabel(text='%sx%s' % (width, height),
                                   scale=0.08,
                                   relief=None,
                                   pos=(0.25, 0, 0))
        self.resSlider = DirectSlider(range=(0, 200),
                                      pageSize=50,
                                      command=self.setResoText,
                                      scale=0.3,
                                      orientation=DGG.VERTICAL,
                                      pos=(0.6, 0, 0))
        self.okBtn = DirectButton(text='OK',
                                  geom=CIGlobals.getOkayBtnGeom(),
                                  relief=None,
                                  pos=(-0.5, -0.5, -0.5),
                                  text_scale=0.05,
                                  text_pos=(0, -0.11),
                                  command=self.applyDisplaySettings)
        self.cancelBtn = DirectButton(text='Cancel',
                                      geom=CIGlobals.getCancelBtnGeom(),
                                      relief=None,
                                      pos=(-0.3, -0.5, -0.5),
                                      text_scale=0.05,
                                      text_pos=(0, -0.11),
                                      command=self.cancelDisplaySettings)
        if self.resoLbl['text'] == '640x480':
            self.resSlider['value'] = 0
        else:
            if self.resoLbl['text'] == '800x600':
                self.resSlider['value'] = 50
            else:
                if self.resoLbl['text'] == '1024x768':
                    self.resSlider['value'] = 100
                else:
                    if self.resoLbl['text'] == '1280x1024':
                        self.resSlider['value'] = 150
                    else:
                        if self.resoLbl['text'] == '1600x1200':
                            self.resSlider['value'] = 200
        return

    def exitDisplayPage(self):
        for button in self.buttons:
            button.destroy()
            del button

        self.resoLbl.destroy()
        del self.resoLbl
        self.resSlider.destroy()
        del self.resSlider
        self.okBtn.destroy()
        del self.okBtn
        self.cancelBtn.destroy()
        del self.cancelBtn
        del self.width
        del self.height
        del self.windowType
        del self.buttons
        self.book.clearTitle()

    def changeSetting(self, setting, value):
        if setting == 'music':
            if value:
                value = False
            else:
                if not value:
                    value = True
            base.enableMusic(value)
            self.music_btn['extraArgs'] = ['music', value]
            if value:
                valueTxt = 'On'
            else:
                valueTxt = 'Off'
            self.music_lbl['text'] = str(valueTxt).capitalize()
        else:
            if setting == 'sfx':
                if value:
                    value = False
                else:
                    if not value:
                        value = True
                base.enableSoundEffects(value)
                self.sfx_btn['extraArgs'] = ['sfx', value]
                if value:
                    valueTxt = 'On'
                else:
                    valueTxt = 'Off'
                self.sfx_lbl['text'] = str(valueTxt).capitalize()
            else:
                if setting == 'model-detail':
                    if value == 'high':
                        value = 'low'
                    else:
                        if value == 'medium':
                            value = 'high'
                        else:
                            if value == 'low':
                                value = 'medium'
                    self.moddet_lbl['text'] = value.capitalize()
                    self.moddet_btn['extraArgs'] = ['model-detail', value]
                else:
                    if setting == 'texture-detail':
                        if value == 'normal':
                            value = 'low'
                            loadPrcFileData('', 'compressed-textures 1')
                        else:
                            if value == 'low':
                                value = 'normal'
                                loadPrcFileData('', 'compressed-textures 0')
                        self.texdet_lbl['text'] = value.capitalize()
                        self.texdet_btn['extraArgs'] = [
                            'texture-detail', value
                        ]
                    else:
                        if setting == 'aa':
                            if value == 'on':
                                value = 'off'
                                render.clear_antialias()
                            else:
                                if value == 'off':
                                    value = 'on'
                                    render.set_antialias(AntialiasAttrib.MAuto)
                            self.aa_lbl['text'] = value.capitalize()
                            self.aa_btn['extraArgs'] = ['aa', value]
                        else:
                            if setting == 'af':
                                if value == 'on':
                                    value = 'off'
                                else:
                                    if value == 'off':
                                        value = 'on'
                                self.af_lbl['text'] = value.capitalize()
                                self.af_btn['extraArgs'] = ['af', value]
        SettingsManager().writeSettingToFile(setting, value, 'settings.json')

    def setResoText(self):
        if self.resSlider['value'] == 200:
            self.width = 1600
            self.height = 1200
        else:
            if 150 <= self.resSlider['value'] <= 199:
                self.width = 1280
                self.height = 1024
            else:
                if 100 <= self.resSlider['value'] <= 149:
                    self.width = 1024
                    self.height = 768
                else:
                    if 50 <= self.resSlider['value'] <= 99:
                        self.width = 800
                        self.height = 600
                    else:
                        if self.resSlider['value'] == 0:
                            self.width = 640
                            self.height = 480
        self.resoLbl['text'] = str(self.width) + 'x' + str(self.height)

    def applyDisplaySettings(self):
        SettingsManager().writeSettingToFile('resolution',
                                             (self.width, self.height),
                                             'settings.json',
                                             apply=1)
        SettingsManager().writeSettingToFile('fullscreen',
                                             self.windowType,
                                             'settings.json',
                                             apply=1)
        self.fsm.request('basePage')

    def cancelDisplaySettings(self):
        self.fsm.request('basePage')

    def enterBasePage(self):
        self.book.createPageButtons(None, 'districtPage')
        self.book.setTitle('Options')
        width, height, fs, music, sfx, tex_detail, model_detail, aa, af = SettingsManager(
        ).getSettings('settings.json')
        if music:
            musicTxt = 'On'
        else:
            musicTxt = 'Off'
        if sfx:
            sfxTxt = 'On'
        else:
            sfxTxt = 'Off'
        if fs:
            fsTxt = 'On'
        else:
            fsTxt = 'Off'
        self.music_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                            qt_btn.find('**/QuitBtn_DN'),
                                            qt_btn.find('**/QuitBtn_RLVR')),
                                      relief=None,
                                      text='Music',
                                      scale=1,
                                      text_scale=0.055,
                                      command=self.changeSetting,
                                      extraArgs=['music', music],
                                      pos=(-0.45, 0.55, 0.55),
                                      text_pos=(0, -0.01))
        self.music_lbl = DirectLabel(relief=None,
                                     scale=0.09,
                                     pos=(0.45, 0.55, 0.52),
                                     text_align=TextNode.ACenter)
        self.music_lbl['text'] = str(musicTxt).capitalize()
        self.sfx_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                          qt_btn.find('**/QuitBtn_DN'),
                                          qt_btn.find('**/QuitBtn_RLVR')),
                                    relief=None,
                                    text='SFX',
                                    scale=1,
                                    text_scale=0.055,
                                    command=self.changeSetting,
                                    extraArgs=['sfx', sfx],
                                    pos=(-0.45, 0.45, 0.45),
                                    text_pos=(0, -0.01))
        self.sfx_lbl = DirectLabel(relief=None,
                                   scale=0.09,
                                   pos=(0.45, 0.45, 0.42),
                                   text_align=TextNode.ACenter)
        self.sfx_lbl['text'] = str(sfxTxt).capitalize()
        self.moddet_btn = DirectButton(
            geom=(qt_btn.find('**/QuitBtn_UP'), qt_btn.find('**/QuitBtn_DN'),
                  qt_btn.find('**/QuitBtn_RLVR')),
            relief=None,
            text='Model Detail',
            scale=1,
            text_scale=0.055,
            command=self.changeSetting,
            extraArgs=['model-detail', model_detail],
            pos=(-0.45, 0.35, 0.35),
            text_pos=(0, -0.01))
        self.moddet_lbl = DirectLabel(relief=None,
                                      scale=0.09,
                                      pos=(0.45, 0.35, 0.32),
                                      text_align=TextNode.ACenter)
        self.moddet_lbl['text'] = model_detail.capitalize()
        self.moddet_btn.bind(DGG.ENTER, self.createMustRestartGui)
        self.moddet_btn.bind(DGG.EXIT, self.removeMustRestartGui)
        self.texdet_btn = DirectButton(
            geom=(qt_btn.find('**/QuitBtn_UP'), qt_btn.find('**/QuitBtn_DN'),
                  qt_btn.find('**/QuitBtn_RLVR')),
            relief=None,
            text='Texture Detail',
            scale=1,
            text_scale=0.0535,
            command=self.changeSetting,
            extraArgs=['texture-detail', tex_detail],
            pos=(-0.45, 0.25, 0.25),
            text_pos=(0, -0.01))
        self.texdet_lbl = DirectLabel(relief=None,
                                      scale=0.09,
                                      pos=(0.45, 0.25, 0.22),
                                      text_align=TextNode.ACenter)
        self.texdet_lbl['text'] = tex_detail.capitalize()
        self.texdet_btn.bind(DGG.ENTER, self.createMustRestartGui)
        self.texdet_btn.bind(DGG.EXIT, self.removeMustRestartGui)
        self.display_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                              qt_btn.find('**/QuitBtn_DN'),
                                              qt_btn.find('**/QuitBtn_RLVR')),
                                        relief=None,
                                        text='Display',
                                        command=self.openDisplayPage,
                                        scale=1,
                                        text_scale=0.0535,
                                        pos=(-0.45, -0.25, 0.02),
                                        text_pos=(0, -0.01))
        self.display_lbl = DirectLabel(relief=None,
                                       scale=0.06,
                                       pos=(0.45, -0.25, 0.02),
                                       text_align=TextNode.ACenter)
        self.display_lbl['text'] = 'Fullscreen: %s\nResolution: %s' % (
            str(fsTxt).capitalize(), (width, height))
        self.aa_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                         qt_btn.find('**/QuitBtn_DN'),
                                         qt_btn.find('**/QuitBtn_RLVR')),
                                   relief=None,
                                   text='Anti-Aliasing',
                                   command=self.changeSetting,
                                   extraArgs=['aa', aa],
                                   scale=1,
                                   text_scale=0.0535,
                                   pos=(-0.45, -0.35, -0.18),
                                   text_pos=(0, -0.01))
        self.aa_lbl = DirectLabel(relief=None,
                                  scale=0.09,
                                  pos=(0.45, -0.35, -0.21),
                                  text_align=TextNode.ACenter)
        self.aa_lbl['text'] = aa.capitalize()
        self.af_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                         qt_btn.find('**/QuitBtn_DN'),
                                         qt_btn.find('**/QuitBtn_RLVR')),
                                   relief=None,
                                   text='Anisotropic Filtering',
                                   command=self.changeSetting,
                                   extraArgs=['af', af],
                                   scale=1,
                                   text_scale=0.0435,
                                   pos=(-0.45, -0.35, -0.28),
                                   text_pos=(0, -0.01))
        self.af_lbl = DirectLabel(relief=None,
                                  scale=0.09,
                                  pos=(0.45, -0.35, -0.31),
                                  text_align=TextNode.ACenter)
        self.af_lbl['text'] = af.capitalize()
        self.af_btn.bind(DGG.ENTER, self.createMustRestartGui)
        self.af_btn.bind(DGG.EXIT, self.removeMustRestartGui)
        self.exit_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                           qt_btn.find('**/QuitBtn_DN'),
                                           qt_btn.find('**/QuitBtn_RLVR')),
                                     relief=None,
                                     text='Exit Toontown',
                                     scale=1.2,
                                     text_scale=0.0535,
                                     command=self.book.finished,
                                     extraArgs=['exit'],
                                     pos=(-0.45, -0.65, -0.6),
                                     text_pos=(0, -0.01))
        return

    def createMustRestartGui(self, foo):
        self.mustRestartLbl = DirectLabel(
            text='Changing this setting requires a game restart.',
            text_fg=(0.9, 0, 0, 1),
            text_shadow=(0, 0, 0, 1),
            text_scale=0.06,
            text_align=TextNode.ACenter,
            pos=(0, 0, -0.435),
            relief=None)
        return

    def removeMustRestartGui(self, foo):
        if hasattr(self, 'mustRestartLbl'):
            self.mustRestartLbl.destroy()
            del self.mustRestartLbl

    def exitBasePage(self):
        self.music_btn.destroy()
        del self.music_btn
        self.sfx_btn.destroy()
        del self.sfx_btn
        self.moddet_btn.destroy()
        del self.moddet_btn
        self.texdet_btn.destroy()
        del self.texdet_btn
        self.display_btn.destroy()
        del self.display_btn
        self.aa_btn.destroy()
        del self.aa_btn
        self.exit_btn.destroy()
        del self.exit_btn
        self.music_lbl.destroy()
        del self.music_lbl
        self.sfx_lbl.destroy()
        del self.sfx_lbl
        self.moddet_lbl.destroy()
        del self.moddet_lbl
        self.texdet_lbl.destroy()
        del self.texdet_lbl
        self.display_lbl.destroy()
        del self.display_lbl
        self.aa_lbl.destroy()
        del self.aa_lbl
        self.af_btn.destroy()
        del self.af_btn
        self.af_lbl.destroy()
        del self.af_lbl
        self.book.deletePageButtons(False, True)
        self.book.clearTitle()
Esempio n. 24
0
class Option:
    """docstring for Option"""
    def __init__(self):
        self.testMusic = loader.loadMusic("Audio/click.wav")
        self.testSfx = loader.loadSfx("Audio/click.wav")
        self.frameOption = DirectFrame(image="gui/BackGround_o.png",
                                       image_scale=(1.7778, 1, 1),
                                       frameSize=(base.a2dLeft, base.a2dRight,
                                                  base.a2dBottom, base.a2dTop),
                                       frameColor=(0, 0, 0, 0))
        self.frameOption.setTransparency(1)

        self.title = DirectLabel(scale=0.15,
                                 text_align=TextNode.ALeft,
                                 pos=(-0.3, 0, 0.5),
                                 frameColor=(0, 0, 0, 0),
                                 text="",
                                 text_fg=(1, 1, 1, 1))
        self.title.setTransparency(1)
        self.title.reparentTo(self.frameOption)

        self.title_volume = DirectLabel(scale=0.1,
                                        text_align=TextNode.ALeft,
                                        pos=(base.a2dLeft + 1.3, 0, -0.2),
                                        frameColor=(0, 0, 0, 0),
                                        text="Music",
                                        text_fg=(1, 1, 1, 1))
        self.title_volume.setTransparency(1)
        self.title_volume.reparentTo(self.frameOption)

        self.slider_volume = DirectSlider(pos=(base.a2dLeft + 2.2, 0, -0.2),
                                          value=50,
                                          range=(0, 100),
                                          pageSize=5,
                                          scale=0.5,
                                          command=base.messenger.send,
                                          extraArgs=["ChangeVolume"])
        self.slider_volume.reparentTo(self.frameOption)

        self.testMusicBtn = self.createButton(-0.2, self.testMusic)

        self.title_sound = DirectLabel(scale=0.1,
                                       text_align=TextNode.ALeft,
                                       pos=(base.a2dLeft + 1.3, 0, -0.4),
                                       frameColor=(0, 0, 0, 0),
                                       text="Sfx",
                                       text_fg=(1, 1, 1, 1))
        self.title_sound.setTransparency(1)
        self.title_sound.reparentTo(self.frameOption)
        self.slider_sound = DirectSlider(
            pos=(base.a2dLeft + 2.2, 0, -0.4),
            value=50,
            range=(0, 100),
            pageSize=5,
            #frameSize = (1,1,1,1)
            scale=0.5,
            command=base.messenger.send,
            extraArgs=["ChangeSound"])
        self.slider_sound.reparentTo(self.frameOption)
        self.testSfxBtn = self.createButton(-0.4, self.testSfx)
        # self.title_leapmotion = DirectLabel(
        #   scale = 0.1,
        #   text_align = TextNode.ALeft,
        #   pos = (base.a2dLeft + 0.6 , 0, -0.6),
        #   frameColor = (0, 0, 0, 0),
        #   text = "Leapmotion",
        #   text_fg = (1,1,1,1))
        # self.title_leapmotion.reparentTo(self.frameOption)
        # self.cbtn_leapmotion = DirectCheckButton(
        #   text = "needed",text_fg=(1,1,1,1),
        #   scale = .1,
        #   pos = (base.a2dLeft + 1.5 , 0, -0.6),
        #   command = base.messenger.send,
        #   extraArgs = ["ChangeLeapmotion"])
        # self.cbtn_leapmotion.reparentTo(self.frameOption)

        self.hide()

    def createButton(self, verticalPos, eventArgs):
        maps = loader.loadModel("gui/button_map")
        btnGeom = (maps.find("**/btn_ready"), maps.find("**/btn_click"),
                   maps.find("**/btn_rollover"), maps.find("**/btn_disabled"))
        btn = DirectButton(text="apply",
                           text_fg=(1, 1, 1, 1),
                           text_scale=0.05,
                           text_pos=(0.15, -0.013),
                           text_align=TextNode.ALeft,
                           scale=2,
                           geom=btnGeom,
                           pos=(base.a2dRight - 0.7, 0, verticalPos),
                           relief=0,
                           frameColor=(1, 1, 1, 1),
                           command=self.testPlay,
                           extraArgs=[
                               eventArgs,
                           ],
                           pressEffect=True,
                           rolloverSound=None)
        btn.reparentTo(self.frameOption)
        btn.setTransparency(1)
        return btn

    def testPlay(self, sound):
        sound.play()

    def show(self):
        self.frameOption.show()

    def hide(self):
        self.frameOption.hide()
Esempio n. 25
0
class OptionPage(StateData):
    def __init__(self, book, parentFSM):
        self.book = book
        self.parentFSM = parentFSM
        StateData.__init__(self, 'optionPageDone')
        self.fsm = ClassicFSM('OptionPage', [
            State('off', self.enterOff, self.exitOff),
            State('basePage', self.enterBasePage, self.exitBasePage),
            State('displayPage', self.enterDisplayPage, self.exitDisplayPage)
        ], 'off', 'off')
        self.fsm.enterInitialState()
        self.parentFSM.getStateNamed('optionPage').addChild(self.fsm)

    def enterOff(self):
        pass

    def exitOff(self):
        pass

    def load(self):
        StateData.load(self)

    def unload(self):
        StateData.unload(self)

    def enter(self):
        StateData.enter(self)
        self.fsm.request('basePage')

    def exit(self):
        self.fsm.request('off')
        StateData.exit(self)

    def openDisplayPage(self):
        self.fsm.request('displayPage')

    def enterDisplayPage(self):
        self.book.createPageButtons(False, False)
        self.book.setTitle("Display Options")
        dialog_gui = loader.loadModel(
            "phase_3/models/gui/dialog_box_buttons_gui.bam")
        width, height, fs, music, sfx, tex_detail, model_detail, aa, af = SettingsManager(
        ).getSettings("settings.json")
        self.width = width
        self.height = height
        self.windowType = [fs]
        self.buttons = [
            DirectRadioButton(text="Windowed",
                              variable=self.windowType,
                              value=[False],
                              scale=0.1,
                              pos=(-0.45, 0.15, 0.15)),
            DirectRadioButton(text="Fullscreen",
                              variable=self.windowType,
                              value=[True],
                              scale=0.1,
                              pos=(-0.45, -0.15, -0.15))
        ]

        for button in self.buttons:
            button.setOthers(self.buttons)

        self.resoLbl = DirectLabel(text="%sx%s" % (width, height),
                                   scale=0.08,
                                   relief=None,
                                   pos=(0.25, 0, 0))
        self.resSlider = DirectSlider(range=(0, 200),
                                      pageSize=50,
                                      command=self.setResoText,
                                      scale=0.3,
                                      orientation=DGG.VERTICAL,
                                      pos=(0.6, 0, 0))
        self.okBtn = DirectButton(text="OK",
                                  geom=CIGlobals.getOkayBtnGeom(),
                                  relief=None,
                                  pos=(-0.5, -0.5, -0.5),
                                  text_scale=0.05,
                                  text_pos=(0, -0.11),
                                  command=self.applyDisplaySettings)
        self.cancelBtn = DirectButton(text="Cancel",
                                      geom=CIGlobals.getCancelBtnGeom(),
                                      relief=None,
                                      pos=(-0.3, -0.5, -0.5),
                                      text_scale=0.05,
                                      text_pos=(0, -0.11),
                                      command=self.cancelDisplaySettings)
        if self.resoLbl['text'] == "640x480":
            self.resSlider['value'] = 0
        elif self.resoLbl['text'] == "800x600":
            self.resSlider['value'] = 50
        elif self.resoLbl['text'] == "1024x768":
            self.resSlider['value'] = 100
        elif self.resoLbl['text'] == "1280x1024":
            self.resSlider['value'] = 150
        elif self.resoLbl['text'] == "1600x1200":
            self.resSlider['value'] = 200

    def exitDisplayPage(self):
        for button in self.buttons:
            button.destroy()
            del button
        self.resoLbl.destroy()
        del self.resoLbl
        self.resSlider.destroy()
        del self.resSlider
        self.okBtn.destroy()
        del self.okBtn
        self.cancelBtn.destroy()
        del self.cancelBtn
        del self.width
        del self.height
        del self.windowType
        del self.buttons
        self.book.clearTitle()

    def changeSetting(self, setting, value):
        if setting == "music":
            if value:
                value = False
            elif not value:
                value = True
            base.enableMusic(value)
            self.music_btn['extraArgs'] = ["music", value]
            if value:
                valueTxt = "On"
            else:
                valueTxt = "Off"
            self.music_lbl['text'] = str(valueTxt).capitalize()
        elif setting == "sfx":
            if value:
                value = False
            elif not value:
                value = True
            base.enableSoundEffects(value)
            self.sfx_btn['extraArgs'] = ["sfx", value]
            if value:
                valueTxt = "On"
            else:
                valueTxt = "Off"
            self.sfx_lbl['text'] = str(valueTxt).capitalize()
        elif setting == "model-detail":
            if value == "high":
                value = "low"
            elif value == "medium":
                value = "high"
            elif value == "low":
                value = "medium"
            self.moddet_lbl['text'] = value.capitalize()
            self.moddet_btn['extraArgs'] = ["model-detail", value]
        elif setting == "texture-detail":
            if value == "normal":
                value = "low"
                loadPrcFileData("", "compressed-textures 1")
            elif value == "low":
                value = "normal"
                loadPrcFileData("", "compressed-textures 0")
            self.texdet_lbl['text'] = value.capitalize()
            self.texdet_btn['extraArgs'] = ["texture-detail", value]
        elif setting == "aa":
            if value == "on":
                value = "off"
                render.clear_antialias()
            elif value == "off":
                value = "on"
                render.set_antialias(AntialiasAttrib.MAuto)
            self.aa_lbl['text'] = value.capitalize()
            self.aa_btn['extraArgs'] = ["aa", value]
        elif setting == "af":
            if value == "on":
                value = "off"
            elif value == "off":
                value = "on"
            self.af_lbl['text'] = value.capitalize()
            self.af_btn['extraArgs'] = ["af", value]

        SettingsManager().writeSettingToFile(setting, value, "settings.json")

    def setResoText(self):
        if self.resSlider['value'] == 200:
            self.width = 1600
            self.height = 1200
        elif 150 <= self.resSlider['value'] <= 199:
            self.width = 1280
            self.height = 1024
        elif 100 <= self.resSlider['value'] <= 149:
            self.width = 1024
            self.height = 768
        elif 50 <= self.resSlider['value'] <= 99:
            self.width = 800
            self.height = 600
        elif self.resSlider['value'] == 0:
            self.width = 640
            self.height = 480
        self.resoLbl['text'] = str(self.width) + "x" + str(self.height)

    def applyDisplaySettings(self):
        SettingsManager().writeSettingToFile("resolution",
                                             (self.width, self.height),
                                             "settings.json",
                                             apply=1)
        SettingsManager().writeSettingToFile("fullscreen",
                                             self.windowType,
                                             "settings.json",
                                             apply=1)
        self.fsm.request('basePage')

    def cancelDisplaySettings(self):
        self.fsm.request('basePage')

    def enterBasePage(self):
        self.book.createPageButtons(None, 'districtPage')
        self.book.setTitle("Options")
        width, height, fs, music, sfx, tex_detail, model_detail, aa, af = SettingsManager(
        ).getSettings("settings.json")
        if music:
            musicTxt = "On"
        else:
            musicTxt = "Off"
        if sfx:
            sfxTxt = "On"
        else:
            sfxTxt = "Off"
        if fs:
            fsTxt = "On"
        else:
            fsTxt = "Off"
        self.music_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                            qt_btn.find('**/QuitBtn_DN'),
                                            qt_btn.find('**/QuitBtn_RLVR')),
                                      relief=None,
                                      text="Music",
                                      scale=1,
                                      text_scale=0.055,
                                      command=self.changeSetting,
                                      extraArgs=["music", music],
                                      pos=(-0.45, 0.55, 0.55),
                                      text_pos=(0, -0.01))
        self.music_lbl = DirectLabel(relief=None,
                                     scale=0.09,
                                     pos=(0.45, 0.55, 0.52),
                                     text_align=TextNode.ACenter)
        self.music_lbl['text'] = str(musicTxt).capitalize()

        self.sfx_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                          qt_btn.find('**/QuitBtn_DN'),
                                          qt_btn.find('**/QuitBtn_RLVR')),
                                    relief=None,
                                    text="SFX",
                                    scale=1,
                                    text_scale=0.055,
                                    command=self.changeSetting,
                                    extraArgs=["sfx", sfx],
                                    pos=(-0.45, 0.45, 0.45),
                                    text_pos=(0, -0.01))
        self.sfx_lbl = DirectLabel(relief=None,
                                   scale=0.09,
                                   pos=(0.45, 0.45, 0.42),
                                   text_align=TextNode.ACenter)
        self.sfx_lbl['text'] = str(sfxTxt).capitalize()

        self.moddet_btn = DirectButton(
            geom=(qt_btn.find('**/QuitBtn_UP'), qt_btn.find('**/QuitBtn_DN'),
                  qt_btn.find('**/QuitBtn_RLVR')),
            relief=None,
            text="Model Detail",
            scale=1,
            text_scale=0.055,
            command=self.changeSetting,
            extraArgs=["model-detail", model_detail],
            pos=(-0.45, 0.35, 0.35),
            text_pos=(0, -0.01))
        self.moddet_lbl = DirectLabel(relief=None,
                                      scale=0.09,
                                      pos=(0.45, 0.35, 0.32),
                                      text_align=TextNode.ACenter)
        self.moddet_lbl['text'] = model_detail.capitalize()
        self.moddet_btn.bind(DGG.ENTER, self.createMustRestartGui)
        self.moddet_btn.bind(DGG.EXIT, self.removeMustRestartGui)

        self.texdet_btn = DirectButton(
            geom=(qt_btn.find('**/QuitBtn_UP'), qt_btn.find('**/QuitBtn_DN'),
                  qt_btn.find('**/QuitBtn_RLVR')),
            relief=None,
            text="Texture Detail",
            scale=1,
            text_scale=0.0535,
            command=self.changeSetting,
            extraArgs=["texture-detail", tex_detail],
            pos=(-0.45, 0.25, 0.25),
            text_pos=(0, -0.01))
        self.texdet_lbl = DirectLabel(relief=None,
                                      scale=0.09,
                                      pos=(0.45, 0.25, 0.22),
                                      text_align=TextNode.ACenter)
        self.texdet_lbl['text'] = tex_detail.capitalize()
        self.texdet_btn.bind(DGG.ENTER, self.createMustRestartGui)
        self.texdet_btn.bind(DGG.EXIT, self.removeMustRestartGui)

        self.display_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                              qt_btn.find('**/QuitBtn_DN'),
                                              qt_btn.find('**/QuitBtn_RLVR')),
                                        relief=None,
                                        text="Display",
                                        command=self.openDisplayPage,
                                        scale=1,
                                        text_scale=0.0535,
                                        pos=(-0.45, -0.25, 0.02),
                                        text_pos=(0, -0.01))
        self.display_lbl = DirectLabel(relief=None,
                                       scale=0.06,
                                       pos=(0.45, -0.25, 0.02),
                                       text_align=TextNode.ACenter)
        self.display_lbl['text'] = "Fullscreen: %s\nResolution: %s" % (
            str(fsTxt).capitalize(), (width, height))

        self.aa_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                         qt_btn.find('**/QuitBtn_DN'),
                                         qt_btn.find('**/QuitBtn_RLVR')),
                                   relief=None,
                                   text="Anti-Aliasing",
                                   command=self.changeSetting,
                                   extraArgs=["aa", aa],
                                   scale=1,
                                   text_scale=0.0535,
                                   pos=(-0.45, -0.35, -0.18),
                                   text_pos=(0, -0.01))
        self.aa_lbl = DirectLabel(relief=None,
                                  scale=0.09,
                                  pos=(0.45, -0.35, -0.21),
                                  text_align=TextNode.ACenter)
        self.aa_lbl['text'] = aa.capitalize()

        self.af_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                         qt_btn.find('**/QuitBtn_DN'),
                                         qt_btn.find('**/QuitBtn_RLVR')),
                                   relief=None,
                                   text="Anisotropic Filtering",
                                   command=self.changeSetting,
                                   extraArgs=["af", af],
                                   scale=1,
                                   text_scale=0.0435,
                                   pos=(-0.45, -0.35, -0.28),
                                   text_pos=(0, -0.01))
        self.af_lbl = DirectLabel(relief=None,
                                  scale=0.09,
                                  pos=(0.45, -0.35, -0.31),
                                  text_align=TextNode.ACenter)
        self.af_lbl['text'] = af.capitalize()
        self.af_btn.bind(DGG.ENTER, self.createMustRestartGui)
        self.af_btn.bind(DGG.EXIT, self.removeMustRestartGui)

        self.exit_btn = DirectButton(geom=(qt_btn.find('**/QuitBtn_UP'),
                                           qt_btn.find('**/QuitBtn_DN'),
                                           qt_btn.find('**/QuitBtn_RLVR')),
                                     relief=None,
                                     text="Exit Toontown",
                                     scale=1.2,
                                     text_scale=0.0535,
                                     command=self.book.finished,
                                     extraArgs=["exit"],
                                     pos=(-0.45, -0.65, -0.60),
                                     text_pos=(0, -0.01))

    def createMustRestartGui(self, foo):
        self.mustRestartLbl = DirectLabel(
            text="Changing this setting requires a game restart.",
            text_fg=(0.9, 0, 0, 1),
            text_shadow=(0, 0, 0, 1),
            text_scale=0.06,
            text_align=TextNode.ACenter,
            pos=(0, 0, -0.435),
            relief=None)

    def removeMustRestartGui(self, foo):
        if hasattr(self, 'mustRestartLbl'):
            self.mustRestartLbl.destroy()
            del self.mustRestartLbl

    def exitBasePage(self):
        self.music_btn.destroy()
        del self.music_btn
        self.sfx_btn.destroy()
        del self.sfx_btn
        self.moddet_btn.destroy()
        del self.moddet_btn
        self.texdet_btn.destroy()
        del self.texdet_btn
        self.display_btn.destroy()
        del self.display_btn
        self.aa_btn.destroy()
        del self.aa_btn
        self.exit_btn.destroy()
        del self.exit_btn
        self.music_lbl.destroy()
        del self.music_lbl
        self.sfx_lbl.destroy()
        del self.sfx_lbl
        self.moddet_lbl.destroy()
        del self.moddet_lbl
        self.texdet_lbl.destroy()
        del self.texdet_lbl
        self.display_lbl.destroy()
        del self.display_lbl
        self.aa_lbl.destroy()
        del self.aa_lbl
        self.af_btn.destroy()
        del self.af_btn
        self.af_lbl.destroy()
        del self.af_lbl
        self.book.deletePageButtons(False, True)
        self.book.clearTitle()
Esempio n. 26
0
    def __init__(self):
        self.frameMain = DirectFrame(
            image="gui/MenuBackground.png",
            image_scale=(1.7778, 1, 1),
            #image_pos=(0, 0, 0.25),
            frameSize=(
                base.a2dLeft, base.a2dRight,
                base.a2dTop, base.a2dBottom),
            frameColor=(0,0,0,0))
        self.frameMain.setTransparency(True)

        self.logo = DirectFrame(
            image="Logo.png",
            image_scale=0.25,
            image_pos=(0, 0, 0.55),
            frameSize=(
                base.a2dLeft, base.a2dRight,
                base.a2dTop, base.a2dBottom),
            frameColor=(0,0,0,0))
        self.logo.reparentTo(self.frameMain)


        btnGeom = "gui/button"

        self.btnBack = menuHelper.createButton(_("Back"), btnGeom, 0, -0.7, ["options_back"])
        self.btnBack.reparentTo(self.frameMain)


        volume = base.musicManager.getVolume()
        self.sliderVolume = DirectSlider(
            scale=0.5,
            pos=(-0.5, 0, 0),
            range=(0, 1),
            scrollSize=0.01,
            text=_("Volume %d%%") % volume*100,
            text_scale=0.1,
            text_pos=(0, 0.15),
            text_fg=(1, 1, 1, 1),
            thumb_frameColor=(0,0.75, 0.25, 1),
            frameColor=(0.35, 0.15, 0.05, 1),
            value=volume,
            command=self.sliderVolume_ValueChanged)
        self.sliderVolume.reparentTo(self.frameMain)

        isChecked = not base.AppHasAudioFocus
        img = None
        imgON = "gui/AudioSwitch_on.png"
        imgOFF = "gui/AudioSwitch_off.png"
        if base.AppHasAudioFocus:
            img = imgON
        else:
            img = imgOFF
        self.cbVolumeMute = DirectCheckBox(
            text=_("Mute Audio"),
            text_scale=0.5,
            text_align=TextNode.ACenter,
            text_pos=(0, 0.65),
            text_fg=(1, 1, 1, 1),
            scale=0.105,
            pos=(0.5, 0, 0),
            command=self.cbVolumeMute_CheckedChanged,
            relief=None,
            pressEffect=False,
            isChecked=isChecked,
            image=img,
            image_scale=0.5,
            checkedImage=imgOFF,
            uncheckedImage=imgON)
        self.cbVolumeMute.setTransparency(True)
        self.cbVolumeMute.setImage()
        self.cbVolumeMute.reparentTo(self.frameMain)

        prcPath = os.path.join(basedir, "%s.prc"%appName)
        self.advancedOptions = DirectLabel(
            text=_("Advanced options can be made in the following text file\n%s")%prcPath,
            text_scale=0.5,
            text_fg=(1, 1, 1, 1),
            scale=0.1,
            pos=(0, 0, -0.25),
            frameColor=(0, 0, 0, 0))
        self.advancedOptions.setTransparency(True)
        self.advancedOptions.reparentTo(self.frameMain)

        self.hide()
Esempio n. 27
0
    def __init__(self):
        self.testMusic = loader.loadMusic("Audio/click.wav")
        self.testSfx = loader.loadSfx("Audio/click.wav")
        self.frameOption = DirectFrame(image="gui/BackGround_o.png",
                                       image_scale=(1.7778, 1, 1),
                                       frameSize=(base.a2dLeft, base.a2dRight,
                                                  base.a2dBottom, base.a2dTop),
                                       frameColor=(0, 0, 0, 0))
        self.frameOption.setTransparency(1)

        self.title = DirectLabel(scale=0.15,
                                 text_align=TextNode.ALeft,
                                 pos=(-0.3, 0, 0.5),
                                 frameColor=(0, 0, 0, 0),
                                 text="",
                                 text_fg=(1, 1, 1, 1))
        self.title.setTransparency(1)
        self.title.reparentTo(self.frameOption)

        self.title_volume = DirectLabel(scale=0.1,
                                        text_align=TextNode.ALeft,
                                        pos=(base.a2dLeft + 1.3, 0, -0.2),
                                        frameColor=(0, 0, 0, 0),
                                        text="Music",
                                        text_fg=(1, 1, 1, 1))
        self.title_volume.setTransparency(1)
        self.title_volume.reparentTo(self.frameOption)

        self.slider_volume = DirectSlider(pos=(base.a2dLeft + 2.2, 0, -0.2),
                                          value=50,
                                          range=(0, 100),
                                          pageSize=5,
                                          scale=0.5,
                                          command=base.messenger.send,
                                          extraArgs=["ChangeVolume"])
        self.slider_volume.reparentTo(self.frameOption)

        self.testMusicBtn = self.createButton(-0.2, self.testMusic)

        self.title_sound = DirectLabel(scale=0.1,
                                       text_align=TextNode.ALeft,
                                       pos=(base.a2dLeft + 1.3, 0, -0.4),
                                       frameColor=(0, 0, 0, 0),
                                       text="Sfx",
                                       text_fg=(1, 1, 1, 1))
        self.title_sound.setTransparency(1)
        self.title_sound.reparentTo(self.frameOption)
        self.slider_sound = DirectSlider(
            pos=(base.a2dLeft + 2.2, 0, -0.4),
            value=50,
            range=(0, 100),
            pageSize=5,
            #frameSize = (1,1,1,1)
            scale=0.5,
            command=base.messenger.send,
            extraArgs=["ChangeSound"])
        self.slider_sound.reparentTo(self.frameOption)
        self.testSfxBtn = self.createButton(-0.4, self.testSfx)
        # self.title_leapmotion = DirectLabel(
        #   scale = 0.1,
        #   text_align = TextNode.ALeft,
        #   pos = (base.a2dLeft + 0.6 , 0, -0.6),
        #   frameColor = (0, 0, 0, 0),
        #   text = "Leapmotion",
        #   text_fg = (1,1,1,1))
        # self.title_leapmotion.reparentTo(self.frameOption)
        # self.cbtn_leapmotion = DirectCheckButton(
        #   text = "needed",text_fg=(1,1,1,1),
        #   scale = .1,
        #   pos = (base.a2dLeft + 1.5 , 0, -0.6),
        #   command = base.messenger.send,
        #   extraArgs = ["ChangeLeapmotion"])
        # self.cbtn_leapmotion.reparentTo(self.frameOption)

        self.hide()
Esempio n. 28
0
    def __init__(self):
        self.frameMain = DirectFrame(image="optionsmenu.png",
                                     image_scale=(1.7778, 1, 1),
                                     frameSize=(base.a2dLeft, base.a2dRight,
                                                base.a2dBottom, base.a2dTop),
                                     frameColor=(0, 0, 0, 0))
        self.frameMain.setTransparency(True)

        volume = base.musicManager.getVolume()
        self.sliderMusicVolume = DirectSlider(
            scale=0.5,
            pos=(0, 0, -0.1),
            range=(0, 1),
            scrollSize=0.01,
            text="Music Volume: %d%%" % volume * 100,
            text_scale=0.15,
            text_align=TextNode.ACenter,
            text_pos=(.0, 0.15),
            text_fg=(240 / 255.0, 255 / 255.0, 240 / 255.0, 1),
            thumb_frameColor=(0.8, 0, 1, 0.75),
            thumb_relief=DGG.FLAT,
            frameColor=(0.25, 0.25, 0.55, 1),
            value=volume,
            command=self.sliderMusicVolume_ValueChanged)
        self.sliderMusicVolume.reparentTo(self.frameMain)

        volume = base.sfxManagerList[0].getVolume()
        self.sliderSFXVolume = DirectSlider(
            scale=0.5,
            pos=(0, 0, -0.3),
            range=(0, 1),
            scrollSize=0.01,
            text="SFX Volume: %d%%" % volume * 100,
            text_scale=0.15,
            text_align=TextNode.ACenter,
            text_pos=(.0, 0.15),
            text_fg=(240 / 255.0, 255 / 255.0, 240 / 255.0, 1),
            thumb_frameColor=(0.8, 0, 1, 0.75),
            thumb_relief=DGG.FLAT,
            frameColor=(0.25, 0.25, 0.55, 1),
            value=volume,
            command=self.sliderSFXVolume_ValueChanged)
        self.sliderSFXVolume.reparentTo(self.frameMain)

        isChecked = not base.AppHasAudioFocus
        img = None
        imgON = "AudioSwitch_on.png"
        imgOFF = "AudioSwitch_off.png"
        if base.AppHasAudioFocus:
            img = imgON
        else:
            img = imgOFF
        self.cbVolumeMute = DirectCheckBox(
            scale=0.5,
            text="Mute Audio",
            text_scale=0.15,
            text_align=TextNode.ACenter,
            text_pos=(0.0, 0.15),
            text_fg=(240 / 255.0, 255 / 255.0, 240 / 255.0, 1),
            pos=(0, 0, -0.5),
            command=self.cbVolumeMute_CheckedChanged,
            rolloverSound=None,
            clickSound=None,
            relief=None,
            pressEffect=False,
            isChecked=isChecked,
            image=img,
            image_scale=0.1,
            checkedImage=imgOFF,
            uncheckedImage=imgON)
        self.cbVolumeMute.setTransparency(True)
        self.cbVolumeMute.setImage()
        self.cbVolumeMute.reparentTo(self.frameMain)

        radio = base.loader.loadModel("radioBtn")
        radioGeom = (radio.find("**/RadioButtonReady"),
                     radio.find("**/RadioButtonChecked"))

        self.lblDifficulty = DirectLabel(text="Difficulty",
                                         text_fg=(240 / 255.0, 255 / 255.0,
                                                  240 / 255.0, 1),
                                         text_scale=0.6,
                                         scale=0.15,
                                         frameColor=(0, 0, 0, 0),
                                         pos=(-0.5, 0, -0.6))
        self.lblDifficulty.reparentTo(self.frameMain)
        self.difficulty = [base.difficulty]

        def createDifficultyDRB(self, text, value, initialValue, xPos):
            drb = DirectRadioButton(
                text=text,
                text_fg=(240 / 255.0, 255 / 255.0, 240 / 255.0, 1),
                variable=self.difficulty,
                value=value,
                indicatorValue=initialValue,
                boxGeom=radioGeom,
                boxGeomScale=0.5,
                #indicator_pad = (0.1, 0.1),
                scale=0.05,
                frameColor=(0.5, 0.5, 0.5, 1),
                pressEffect=False,
                relief=1,
                pad=(0.5, 0, 0.5, 0.5),
                pos=(xPos, 0, -0.6),
                command=self.rbDifficulty_ValueChanged)
            drb.indicator.setX(drb.indicator.getX() + 0.1)
            drb.indicator.setZ(drb.indicator.getZ() + 0.1)
            drb.reparentTo(self.frameMain)
            return drb

        self.difficultyButtons = [
            createDifficultyDRB(self, "Easy", [0],
                                1 if base.difficulty == 0 else 0, 0.5 - 0.3),
            createDifficultyDRB(self, "Medium", [1],
                                1 if base.difficulty == 1 else 0, 0.5),
            createDifficultyDRB(self, "Hard", [2],
                                1 if base.difficulty == 2 else 0, 0.5 + 0.3)
        ]
        for button in self.difficultyButtons:
            button.setOthers(self.difficultyButtons)

        self.btnBack = DirectButton(text="Back",
                                    scale=0.15,
                                    text_pos=(-0.3, -0.2),
                                    text_scale=0.6,
                                    text_fg=(240 / 255.0, 255 / 255.0,
                                             240 / 255.0, 1),
                                    frameColor=(0, 0, 0, 0),
                                    image=("btnExit.png", "btnExit_hover.png",
                                           "btnExit_hover.png",
                                           "btnExit_hover.png"),
                                    image_scale=(1, 1, 0.5),
                                    pos=(0, 0, -0.8),
                                    command=base.messenger.send,
                                    extraArgs=["menu_Back"])
        self.btnBack.setTransparency(True)
        self.btnBack.reparentTo(self.frameMain)

        self.hide()
Esempio n. 29
0
    def __init__(self, mesh_path, progressive_texture_path):

        resolutions = []
        f = tarfile.open(progressive_texture_path)
        for resolution_name in f.getnames():
            toset = {
                'size': resolution_name[:-4],
                'contents': f.extractfile(resolution_name).read()
            }
            texpnm = PNMImage()
            texpnm.read(StringStream(toset['contents']), 'something.jpg')
            newtex = Texture()
            newtex.load(texpnm)
            toset['texture'] = newtex
            resolutions.append(toset)

        self.resolutions = resolutions

        def aux_loader(fname):
            return resolutions[0]['contents']

        mesh = collada.Collada(mesh_path, aux_file_loader=aux_loader)

        scene_members = getSceneMembers(mesh)

        base = ShowBase()

        rotateNode = GeomNode("rotater")
        rotatePath = render.attachNewNode(rotateNode)
        matrix = numpy.identity(4)
        if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
            r = collada.scene.RotateTransform(0, 1, 0, 90)
            matrix = r.matrix
        elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
            r = collada.scene.RotateTransform(1, 0, 0, 90)
            matrix = r.matrix
        rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))

        geom, renderstate, mat4 = scene_members[0]
        node = GeomNode("primitive")
        node.addGeom(geom)
        if renderstate is not None:
            node.setGeomState(0, renderstate)
        self.geomPath = rotatePath.attachNewNode(node)
        self.geomPath.setMat(mat4)

        wrappedNode = ensureCameraAt(self.geomPath, base.camera)
        base.disableMouse()
        attachLights(render)
        render.setShaderAuto()
        render.setTransparency(TransparencyAttrib.MDual, 1)

        base.render.analyze()
        KeyboardMovement()
        MouseDrag(wrappedNode)
        MouseScaleZoom(wrappedNode)
        MouseCamera()

        num_resolutions = len(resolutions) - 1
        self.slider = DirectSlider(range=(0, num_resolutions),
                                   value=0,
                                   pageSize=1,
                                   command=self.sliderMoved,
                                   pos=(0, 0, -.9),
                                   scale=1)
        for key, val in uiArgs.iteritems():
            self.slider.thumb[key] = val

        self.triText = OnscreenText(text="",
                                    pos=(-1, 0.85),
                                    scale=0.15,
                                    fg=(1, 0.5, 0.5, 1),
                                    align=TextNode.ALeft,
                                    mayChange=1)

        base.run()
Esempio n. 30
0
    def initGeneralTab(self):
        """
        This function will set up the content of the
        general tab
        """
        self.frameGeneral = DirectFrame(
            # size of the frame
            frameSize = (base.a2dLeft, base.a2dRight,
                         -0.6, 0.6),
            # position of the frame
            pos = (0, 0, 0),
            # tramsparent bg color
            frameColor = (0, 0, 0, 0.5))

        yPos = 0.45
        shiftY = 0.25

        self.lblLanguage = DirectLabel(
            text = _("Language"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.cmbLanguage = DirectOptionMenu(
            text = "languages",
            scale = 0.15,
            pos = (base.a2dRight - 1.5, 0, 0.45),
            items = ["Deutsch","English","русский", "français"],
            initialitem = 0,
            highlightColor = (0.65,0.65,0.65,1),
            #text_font = self.defaultFontRegular,
            #item_text_font = self.defaultFontRegular,
            command = self.cmbLanguage_SelectionChanged)

        yPos -= shiftY

        self.lblResolution = DirectLabel(
            text = _("Screen resolution"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        # get the display resolutions
        di = base.pipe.getDisplayInformation()
        sizes = []
        for index in range(di.getTotalDisplayModes()):
            tmptext = "{0}x{1}".format(
                di.getDisplayModeWidth(index),
                di.getDisplayModeHeight(index))
            if not tmptext in sizes:
                sizes.append(tmptext)

        self.cmbResolution = DirectOptionMenu(
            text = "resolutions",
            scale = 0.15,
            pos = (base.a2dRight - 1.5, 0, yPos),
            items = sizes,
            initialitem = 0,
            highlightColor = (0.65, 0.65, 0.65, 1),
            #text_font = self.defaultFontRegular,
            #item_text_font = self.defaultFontRegular,
            command = self.cmbResolution_SelectionChanged)

        yPos -= shiftY

        self.lblGraphicQuality = DirectLabel(
            text = _("Graphic quality"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.graphicqualityTextMap = {
            0:_("Low"),
            1:_("Medium"),
            2:_("High")}
        self.sliderGraphicQuality = DirectSlider(
            scale = 0.5,
            pos = (base.a2dRight - 1, 0, yPos + 0.05),
            range = (0,2),
            scrollSize = 1,
            text = self.graphicqualityTextMap[self.engine.settings.graphicquality],
            text_scale = 0.25,
            text_align = TextNode.ALeft,
            text_pos = (1.1, -0.1),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            value = self.engine.settings.graphicquality,
            command = self.sliderGraphicQuality_ValueChanged)

        yPos -= shiftY

        self.lblVolume = DirectLabel(
            text = _("Volume"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.sliderVolume = DirectSlider(
            scale = 0.5,
            pos = (base.a2dRight - 1, 0, yPos + 0.05),
            range = (0,1),
            scrollSize = 0.01,
            text = str(int(self.engine.settings.volume * 100)) + "%",
            text_scale = 0.25,
            text_align = TextNode.ALeft,
            text_pos = (1.1, -0.1),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            value = self.engine.settings.volume,
            command = self.sliderVolume_ValueChanged)

        yPos -= shiftY

        self.lblVolumeMute = DirectLabel(
            text = _("Mute"),
            scale = 0.15,
            pos = (base.a2dLeft + 0.25, 0, yPos),
            frameColor = (0,0,0,0),
            text_fg = (1,1,1,1),
            #text_font = self.defaultFont,
            text_align = TextNode.ALeft)

        self.cbVolumeMute = DirectCheckBox(
            text = "X",
            pos = (base.a2dRight - 1, 0, yPos),
            scale = (0.25, 0.25, 0.25),
            command = self.cbVolumeMute_CheckedChanged,
            rolloverSound = None,
            clickSound = None,
            relief = 0,
            pressEffect = False,
            #frameColor = (0,0,0,0),
            checkedImage = "gui/buttons/options/SoundSwitch_off.png",
            uncheckedImage = "gui/buttons/options/SoundSwitch_on.png"
            )
        self.cbVolumeMute.setTransparency(1)
        self.cbVolumeMute.setImage()
        self.cbVolumeMute["image_scale"] = 0.25
        self.cbVolumeMute["text"] = ""

        self.createBackButton(self.btnBack_Click)

        self.lblLanguage.reparentTo(self.frameGeneral)
        self.cmbLanguage.reparentTo(self.frameGeneral)
        self.lblResolution.reparentTo(self.frameGeneral)
        self.cmbResolution.reparentTo(self.frameGeneral)
        self.lblGraphicQuality.reparentTo(self.frameGeneral)
        self.sliderGraphicQuality.reparentTo(self.frameGeneral)
        self.lblVolume.reparentTo(self.frameGeneral)
        self.sliderVolume.reparentTo(self.frameGeneral)
        self.lblVolumeMute.reparentTo(self.frameGeneral)
        self.cbVolumeMute.reparentTo(self.frameGeneral)

        self.frameGeneral.reparentTo(self.frameMain)

        self.accept("LanguageChanged", self.setText)