Beispiel #1
0
 def __init__(self):
     super(AboutWindow, self).__init__('GB3 - ' + _T('About'),
                                       ID=0, # no position remembering
                                       Position=('centered', 'centered'),
                                       CloseOnReq=True)
     root = pymui.VGroup()
     self.RootObject = root
     
     top = pymui.HGroup()
     root.AddChild(top)
     
     root.AddChild(pymui.HBar(0))
     
     okbt = pymui.SimpleButton(_T('Ok'))
     okbt.Notify('Pressed', lambda *a: self.CloseWindow(), when=False)
     root.AddChild(pymui.HCenter(okbt))
     
     top.AddChild(pymui.Dtpic('PROGDIR:data/internal/app_logo.png', InnerLeft=6, InnerRight=6))
     top.AddChild(pymui.Text(about_msg.safe_substitute(base=BASE,
                                                  description=DESCRIPTION,
                                                  version=main.VERSION,
                                                  build=main.BUILD,
                                                  date=main.DATE,
                                                  copyright=COPYRIGHT),
                             Frame='Text'))
Beispiel #2
0
    def _do_page_calibration(self, reg):
        top = pymui.VGroup()
        reg.AddChild(pymui.HCenter(pymui.VCenter(top)))

        # Contents automatically controled by the CalibrationBar object
        cal_result_x = pymui.String(Frame='String',
                                    Accept="0123456789.",
                                    FixWidthTxt="######",
                                    Format=pymui.MUIV_String_Format_Right,
                                    CycleChain=True)
        cal_result_y = pymui.String(Frame='String',
                                    Accept="0123456789.",
                                    FixWidthTxt="######",
                                    Format=pymui.MUIV_String_Format_Right,
                                    CycleChain=True)

        self.cal_bar_x = CalibrationBar(prefs['view-metrics-x'],
                                        cal_result_x,
                                        horiz=True,
                                        ShortHelp=_T(cal_text))
        self.cal_bar_y = CalibrationBar(prefs['view-metrics-y'],
                                        cal_result_y,
                                        horiz=False,
                                        ShortHelp=_T(cal_text))

        self.cal_unit = pymui.Cycle(CALIBRATION_UNITS,
                                    Active=CALIBRATION_UNITS.index(
                                        prefs['view-metrics-unit']),
                                    CycleChain=True)

        grp = pymui.ColGroup(
            2,
            Frame='Group',
            Child=(pymui.Label(_T("Calibration unit") + ':'), self.cal_unit,
                   pymui.Label(_T("Horizontal axis") + ':'), cal_result_x,
                   pymui.Label(_T("Vertical axis") + ':'), cal_result_y))
        top.AddChild(self.cal_bar_x)
        top.AddChild(pymui.HGroup(Child=(self.cal_bar_y, pymui.HCenter(grp))))

        def callback(evt, wd):
            wd.value = evt.value.contents

        cal_result_x.Notify('Acknowledge', callback, self.cal_bar_x)
        cal_result_y.Notify('Acknowledge', callback, self.cal_bar_y)
Beispiel #3
0
    def __init__(self, name):
        super(LayerMgr, self).__init__(ID='LayerMgr',
                                       Title=name,
                                       CloseOnReq=True)
        self.name = name

        self.__layctrllist = []
        self._active = None

        top = pymui.VGroup()
        self.RootObject = top

        self.layctrl_grp = pymui.VGroupV(Frame='Virtual',
                                         Spacing=VIRT_GROUP_SPACING)
        self.__space = pymui.VSpace(0)
        self.layctrl_grp.AddTail(self.__space)

        # Layer info group
        layerinfo = pymui.ColGroup(2)
        layerinfo.AddChild(pymui.Label(_T("Blending") + ':'))
        self.blending = pymui.Cycle(model.Layer.OPERATORS_LIST,
                                    CycleChain=True,
                                    ShortHelp=_T("Set layer's blending mode"))
        layerinfo.AddChild(self.blending)
        layerinfo.AddChild(pymui.Label(_T("Opacity") + ':'))
        self.opacity = pymui.Slider(Value=100,
                                    Format='%u%%',
                                    CycleChain=True,
                                    ShortHelp=_T("Set layer's opacity value"))
        layerinfo.AddChild(self.opacity)

        # Layer management buttons
        btn_grp = pymui.ColGroup(4)
        self.btn = {}
        for name, label in [
            ('add', 'Add'),
            ('del', 'Del'),
            ('dup', 'Copy'),
            ('merge', 'Merge'),
            ('up', 'Up'),
            ('down', 'Down'),
            ('top', 'Top'),
            ('bottom', 'Bottom'),
        ]:
            o = self.btn[name] = pymui.SimpleButton(label)
            btn_grp.AddChild(o)

        sc_gp = pymui.Scrollgroup(Contents=self.layctrl_grp, FreeHoriz=False)
        self.__vertbar = sc_gp.VertBar.object
        top.AddChild(sc_gp)
        top.AddChild(pymui.HBar(0))
        top.AddChild(layerinfo)
        top.AddChild(pymui.HBar(0))
        top.AddChild(pymui.HCenter(btn_grp))
Beispiel #4
0
    def _do_page_misc(self, reg):
        top = pymui.VGroup()
        reg.AddChild(pymui.HCenter(pymui.VCenter(top)))

        grp = pymui.ColGroup(2, GroupTitle=_T("Interface"))
        grp.AddChild(pymui.Label(_T("Windows to open at startup") + ':', ))
        box = pymui.ColGroup(2, Frame='Group')
        self._startup_win_bt = {}
        win_list = prefs['pymui-window-open-at-startup']
        d = pymui.GetApp().startup_windows
        for key in sorted(d.keys(),
                          cmp=lambda x, y: cmp(d[x].name, d[y].name)):
            bt = self._startup_win_bt[key] = pymui.CheckMark(key in win_list,
                                                             CycleChain=True)
            box.AddChild(bt)
            box.AddChild(pymui.Label(pymui.MUIX_L + d[key].name))
        grp.AddChild(box)
        top.AddChild(grp)
Beispiel #5
0
    def __init__(self, name):
        super(ColorHarmoniesWindow, self).__init__(ID='CHRM',
                                                   Title=name,
                                                   CloseOnReq=True)
        self.name = name

        self.RootObject = top = pymui.VGroup()
        self.widgets = {}

        self.colorwheel = ColorWeelHarmonies2()        
        top.AddChild(pymui.HCenter(self.colorwheel))

        self.hue = pymui.Slider(Min=0, Max=360, CycleChain=True)
        self.sat = pymui.Slider(Min=0, Max=100, CycleChain=True)
        self.value = pymui.Slider(Min=0, Max=100, CycleChain=True)
        
        self.red = pymui.Slider(Min=0, Max=255, CycleChain=True)
        self.green = pymui.Slider(Min=0, Max=255, CycleChain=True)
        self.blue = pymui.Slider(Min=0, Max=255, CycleChain=True)

        self.colorbox = ColorBox(Frame='Virtual', MaxWidth=16)

        grp = pymui.HGroup()
        grp.AddChild(self.colorbox)
        grp.AddChild(pymui.ColGroup(2, Child=(pymui.Label(_T('Red')+':'), self.red,
                                       pymui.Label(_T('Green')+':'), self.green,
                                       pymui.Label(_T('Blue')+':'), self.blue,
                                       pymui.Label(_T('Hue')+':'), self.hue,
                                       pymui.Label(_T('Saturation')+':'), self.sat,
                                       pymui.Label(_T('Value')+':'), self.value)))
        top.AddChild(grp)                

        bt = pymui.SimpleButton(_T("Use as background"), CycleChain=True)
        top.AddChild(bt)
        self.widgets['AsBgBt'] = bt
        
        top.AddChild(pymui.HBar(3))
        
        toggle_pal = pymui.Text(_T("Toggle Palette panel"),
                                InputMode='Toggle',
                                Frame='Button',
                                Background='ButtonBack',
                                Font=pymui.MUIV_Font_Button,
                                PreParse=pymui.MUIX_C,
                                Selected=True)
        top.AddChild(toggle_pal)
        
        grp = pymui.VGroup(GroupTitle=_T('Palette'))
        top.AddChild(grp)
        
        toggle_pal.Notify('Selected', lambda evt: grp.SetAttr('ShowMe', evt.value.value))
        
        ld_pal = pymui.SimpleButton(_T("Load"), CycleChain=True)
        sv_pal = pymui.SimpleButton(_T("Save"), CycleChain=True)
        del_pal = pymui.SimpleButton(_T("Delete"), CycleChain=True)
        grp.AddChild(pymui.HGroup(Child=(ld_pal, sv_pal, del_pal)))
        
        self._predefpallister = pymui.List(SourceArray=self.palettes_list)
        pal_name_bt = pymui.Text(Frame='Text', CycleChain=True, ShortHelp=_T('Predefined palettes'))
        popup = pymui.Popobject(Object=pymui.Listview(List=self._predefpallister),
                                String=pal_name_bt,
                                Button=pymui.Image(Frame='ImageButton',
                                                   Spec=pymui.MUII_PopUp,
                                                   InputMode='RelVerify',
                                                   CycleChain=True))
                                                     
        grp.AddChild(pymui.HGroup(Child=(pymui.Label(_T('Avails')+':'), popup)))
        sort_luma = pymui.SimpleButton(_T('Luminance'), CycleChain=True)
        sort_hue = pymui.SimpleButton(_T('Hue'), CycleChain=True)
        sort_sat = pymui.SimpleButton(_T('Saturation'), CycleChain=True)
        sort_value = pymui.SimpleButton(_T('Value'), CycleChain=True)
        grp.AddChild(pymui.HGroup(Child=(pymui.Label(_T('Sort by')+':'), sort_luma, sort_hue, sort_sat, sort_value)))
        grp.AddChild(pymui.HBar(0))
        
        vgrp = pymui.VGroup(SameSize=True, Columns=16, Spacing=1, HorizWeight=100, Horiz=False, Background='2:00000000,00000000,00000000')
        grp.AddChild(pymui.HCenter(vgrp))
        self._pal_bt = []
        for i in xrange(256):
            bt = DropColorBox(12, 12)
            vgrp.AddChild(bt)
            bt.Notify('Pressed', self._on_palbt, when=False)
            self._pal_bt.append(bt)

        # Notifications        
        self.hue.Notify('Value', lambda evt: self._set_hsv_channel(evt.value.value / 360., 0))
        self.sat.Notify('Value', lambda evt: self._set_hsv_channel(evt.value.value / 100., 1))
        self.value.Notify('Value', lambda evt: self._set_hsv_channel(evt.value.value / 100., 2))
        
        self.red.Notify('Value', lambda evt: self._set_rgb_channel(evt.value.value / 255., 0))
        self.green.Notify('Value', lambda evt: self._set_rgb_channel(evt.value.value / 255., 1))
        self.blue.Notify('Value', lambda evt: self._set_rgb_channel(evt.value.value / 255., 2))

        ld_pal.Notify('Pressed', self._on_ld_pal_pressed, when=False)
        sv_pal.Notify('Pressed', self._on_sv_pal_pressed, when=False)
        del_pal.Notify('Pressed', self._on_del_pal_pressed, when=False)

        self._predefpallister.Notify('DoubleClick', self._on_popup_predef_sel, popup)
        self._predefpallister.Notify('Active', self._on_predef_list_active, pal_name_bt, del_pal)
        
        sort_luma.Notify('Pressed', lambda evt, cmp: self.sort_palette(cmp), self._cmp_luma, when=False)
        sort_hue.Notify('Pressed', lambda evt, cmp: self.sort_palette(cmp), self._cmp_hue, when=False)
        sort_sat.Notify('Pressed', lambda evt, cmp: self.sort_palette(cmp), self._cmp_sat, when=False)
        sort_value.Notify('Pressed', lambda evt, cmp: self.sort_palette(cmp), self._cmp_value, when=False)
        
        # final setup
        self._use_palette('default')
        
        toggle_pal.Selected = False # start in no palette mode
Beispiel #6
0
    def _do_page_rendering(self, reg):
        top = pymui.VGroup(SameWidth=True)
        reg.AddChild(pymui.HCenter(pymui.VCenter(top)))

        grp = pymui.ColGroup(2, GroupTitle=_T("Antialiasing"))
        grp.AddChild(pymui.Label(_T("Filter level threshold") + ':'))
        self._filter_threshold = pymui.Slider(
            Min=0,
            Max=viewport.DocumentViewPort.MAX_SCALE,
            Default=viewport.DocumentViewPort.DEFAULT_FILTER_THRESHOLD,
            Value=prefs['view-filter-threshold'],
            CycleChain=True)
        grp.AddChild(self._filter_threshold)
        top.AddChild(grp)

        def new_color(parent, label, color):
            rgb = pymui.c_ULONG.ArrayType(3)(*tuple(
                int(x * 255) * 0x01010101 for x in color[:3]))
            field = pymui.Colorfield(CycleChain=True,
                                     InputMode='RelVerify',
                                     Frame='ImageButton',
                                     FixWidth=64,
                                     RGB=rgb)
            cadj = pymui.Coloradjust(CycleChain=True, RGB=rgb)
            bt = pymui.SimpleButton(_T("Close"), CycleChain=True)
            grp = pymui.VGroup(Frame='Group')
            grp.AddChild(cadj)
            grp.AddChild(bt)
            popup = pymui.Popobject(Button=field, Object=grp)
            alpha = pymui.Numericbutton(CycleChain=True,
                                        Min=0,
                                        Max=100,
                                        Default=100,
                                        Value=int(color[3] * 100),
                                        Format="%lu%%",
                                        ShortHelp=_T("Transparency level"))
            cadj.Notify('RGB', lambda evt: field.SetAttr('RGB', evt.value))
            bt.Notify('Pressed', lambda evt: popup.Close(0), when=False)

            parent.AddChild(pymui.Label(_T(label) + ':'))
            parent.AddChild(popup)
            parent.AddChild(alpha)
            return field, alpha

        self._colors = {}
        grp = pymui.ColGroup(3, GroupTitle=_T("Tools colors"))
        self._colors['background'] = new_color(grp, "Text background",
                                               prefs['view-color-bg'])
        self._colors['outlines'] = new_color(grp, "Text outlines",
                                             prefs['view-color-ol'])
        self._colors['text'] = new_color(grp, "Text color",
                                         prefs['view-color-text'])
        self._colors['handler_bg'] = new_color(grp, "Handler background",
                                               prefs['view-color-handler-bg'])
        self._colors['handler_ol'] = new_color(grp, "Handler outlines",
                                               prefs['view-color-handler-ol'])
        self._colors['wheel_bg'] = new_color(grp, "Wheel background",
                                             prefs['view-color-wheel-bg'])
        self._colors['wheel_ol'] = new_color(grp, "Wheel outlines",
                                             prefs['view-color-wheel-ol'])
        self._colors['wheel_sel'] = new_color(grp, "Wheel selection",
                                              prefs['view-color-wheel-sel'])
        self._colors['pp'] = new_color(grp, "PassePartout",
                                       prefs['view-color-passepartout'])
        top.AddChild(grp)

        grp = pymui.ColGroup(2, GroupTitle=_T("Rulers"))
        grp.AddChild(pymui.Label(_T("Background pen") + ':'))
        self._ruler_bg_pen = pymui.Slider(CycleChain=True,
                                          Min=0,
                                          Max=255,
                                          Default=1,
                                          Value=prefs['pymui-ruler-bg-pen'])
        grp.AddChild(self._ruler_bg_pen)
        grp.AddChild(pymui.Label(_T("Foreground pen") + ':'))
        self._ruler_fg_pen = pymui.Slider(CycleChain=True,
                                          Min=0,
                                          Max=255,
                                          Default=1,
                                          Value=prefs['pymui-ruler-fg-pen'])
        grp.AddChild(self._ruler_fg_pen)
        top.AddChild(grp)