NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

gradientEdit.py (16868B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\util\gradientEdit.py
      2 import carbonui.const as uiconst
      3 import trinity
      4 import blue
      5 from carbonui.control.combo import Combo
      6 from carbonui.control.slider import Slider
      7 from carbonui.primitives.container import Container
      8 from carbonui.primitives.sprite import Sprite
      9 from carbonui.control.button import Button
     10 from carbonui.control.checkbox import Checkbox
     11 from carbonui.control.window import Window
     12 
     13 class GradientEditor(Window):
     14     __guid__ = 'form.GradientEditor'
     15     default_width = 300
     16     default_height = 300
     17     default_minSize = (480, 480)
     18     default_windowID = 'GradientEditor'
     19     default_state = uiconst.UI_NORMAL
     20     default_caption = 'Gradient Editor'
     21 
     22     def ApplyAttributes(self, attributes):
     23         Window.ApplyAttributes(self, attributes)
     24         self.buttonBar = Container(parent=self.sr.main, name='buttonBar', padLeft=10, padRight=10, padTop=8, padBottom=8, align=uiconst.TOBOTTOM, height=80)
     25         self.mainEditor = Container(parent=self.sr.main, name='mainEditor', align=uiconst.TOALL)
     26         rightArea = Container(parent=self.mainEditor, name='rightArea', padLeft=8, padRight=8, padTop=8, padBottom=8, align=uiconst.TORIGHT, width=200)
     27         leftArea = Container(parent=self.mainEditor, name='leftArea', align=uiconst.TOALL)
     28         self.rgbSelected = 0
     29         self.rgbPoints = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
     30         self.rgbDivs = [0.0, 0.5, 1.0]
     31         self.alphaSelected = 0
     32         self.alphaPoints = [1.0, 1.0]
     33         self.alphaDivs = [0.0, 1.0]
     34         self.gradientData = {'textureSize': 128,
     35          'rgbPoints': self.rgbPoints,
     36          'rgbDivs': self.rgbDivs,
     37          'rgbInterp': 'linear',
     38          'alphaPoints': self.alphaPoints,
     39          'alphaDivs': self.alphaDivs,
     40          'alphaInterp': 'linear'}
     41         rgbCursorParentCont = Container(parent=leftArea, align=uiconst.TOTOP, height=32)
     42         rgbSliderCont = Container(parent=rgbCursorParentCont, align=uiconst.TOALL, padLeft=20, padRight=20)
     43         self.rgbSelectedSlider = Slider(parent=rgbSliderCont, align=uiconst.TOTOP, label='rgb pos', name='rgbSelectedSlider', height=32, minValue=0, maxValue=1.0, value=0.0, on_dragging=self.OnSliderDragging)
     44         self.rgbCursorCont = Container(parent=leftArea, padLeft=12, padRight=12, height=32, align=uiconst.TOTOP)
     45         alphaSliderCont = Container(parent=leftArea, padLeft=20, padRight=20, align=uiconst.TOBOTTOM, height=32)
     46         self.alphaCursorCont = Container(parent=leftArea, padLeft=12, padRight=12, align=uiconst.TOBOTTOM, height=32)
     47         self.alphaSelectedSlider = Slider(parent=alphaSliderCont, align=uiconst.TOTOP, label='alpha pos', name='alphaSelectedSlider', height=32, minValue=0, maxValue=1.0, value=0.0, on_dragging=self.OnAlphaSliderDragging)
     48         self.gradientPreview = Sprite(parent=leftArea, pos=(20, 20, 20, 20), state=uiconst.UI_NORMAL, align=uiconst.TOALL)
     49         self.UpdateGradientPreview()
     50         self.rgbMode = Combo(top=16, align=uiconst.TOTOP, parent=rightArea, label='RGB Mode', options=[('linear', 'linear'), ('cosine', 'cosine'), ('bezier', 'bezier')], name='rgbMode', select='linear', callback=lambda combo, key, index: self.UpdateGradientData({'rgbInterp': key}))
     51         self.rSlider = Slider(parent=rightArea, label='R', align=uiconst.TOTOP, minValue=0, maxValue=1, value=self.rgbPoints[self.rgbSelected][0], height=28, on_dragging=self.OnRSliderDragging)
     52         self.gSlider = (Slider(parent=rightArea, label='G', align=uiconst.TOTOP, minValue=0, maxValue=1, value=self.rgbPoints[self.rgbSelected][1], height=28, on_dragging=self.OnGSliderDragging),)
     53         self.bSlider = (Slider(parent=rightArea, label='B', align=uiconst.TOTOP, minValue=0, maxValue=1, value=self.rgbPoints[self.rgbSelected][2], height=28, on_dragging=self.OnBSliderDragging),)
     54         Button(parent=rightArea, align=uiconst.TOTOP, label='Delete RGB', func=lambda *args: self.DeleteRGBPoint(self.rgbSelected))
     55         Button(parent=rightArea, align=uiconst.TOTOP, label='Insert RGB', func=lambda *args: self.AddRGBPoint(self.rgbSelected))
     56         self.radialCheck = Checkbox(text='Radial', parent=rightArea, align=uiconst.TOTOP, checked=False, callback=lambda *args: self.UpdateGradientData({}))
     57         Button(parent=rightArea, align=uiconst.TOBOTTOM, label='Insert Alpha', func=lambda *args: self.AddAlphaPoint(self.alphaSelected))
     58         Button(parent=rightArea, align=uiconst.TOBOTTOM, label='Delete Alpha', func=lambda *args: self.DeleteAlphaPoint(self.alphaSelected))
     59         self.alphaSlider = Slider(parent=rightArea, label='A', align=uiconst.TOBOTTOM, minValue=0, maxValue=1, value=1, on_dragging=self.OnASliderDragging, height=28)
     60         self.alphaMode = Combo(align=uiconst.TOBOTTOM, parent=rightArea, label='Alpha Mode', options=[('linear', 'linear'), ('cosine', 'cosine'), ('bezier', 'bezier')], name='alphaMode', select='linear', callback=lambda combo, key, index: self.UpdateGradientData({'alphaInterp': key}))
     61         self.rgbCursors = []
     62         self.rgbCursorSelectedSprite = None
     63         self.CreateRGBCursors()
     64         Button(parent=self.buttonBar, align=uiconst.TOLEFT, label='Copy Data To Clipboard', func=self.CopyConstructorToClipboard)
     65 
     66     def OnASliderDragging(self, slider):
     67         self.AlphaCursor(self.alphaSelected, slider.value)
     68 
     69     def OnRSliderDragging(self, slider):
     70         self.RGBCursor(self.rgbSelected, 0, slider.value)
     71 
     72     def OnGSliderDragging(self, slider):
     73         self.RGBCursor(self.rgbSelected, 1, slider.value)
     74 
     75     def OnBSliderDragging(self, slider):
     76         self.RGBCursor(self.rgbSelected, 2, slider.value)
     77 
     78     def OnAlphaSliderDragging(self, slider):
     79         self.MoveAlphaCursor(self.alphaSelected, slider.value)
     80 
     81     def OnSliderDragging(self, slider):
     82         self.MoveRGBCursor(self.rgbSelected, slider.value)
     83 
     84     def SelectAlphaCursor(self, idx):
     85         self.alphaSelected = idx
     86         self.alphaSlider.SetValue(self.alphaPoints[idx])
     87         self.alphaSelectedSlider.SetValue(self.alphaDivs[idx])
     88 
     89     def MoveAlphaCursor(self, idx, position):
     90         self.alphaDivs[idx] = position
     91         if 'alphaCursorCont' not in self.__dict__:
     92             return
     93         if len(self.alphaCursorCont.children) <= idx:
     94             return
     95         self.alphaCursorCont.children[idx].left = self.alphaCursors[idx].left - 2
     96         self.UpdateGradientData({'alphaDivs': self.alphaDivs})
     97 
     98     def AlphaCursor(self, idx, value):
     99         self.alphaPoints[idx] = value
    100         self.UpdateGradientData({'alphaPoints': self.alphaPoints})
    101 
    102     def SelectRGBCursor(self, idx):
    103         self.rgbSelected = idx
    104         data = self.rgbPoints[idx]
    105         self.rSlider.SetValue(data[0])
    106         self.gSlider.SetValue(data[1])
    107         self.bSlider.SetValue(data[2])
    108         if self.rgbCursorSelectedSprite:
    109             self.rgbCursorSelectedSprite.left = self.rgbCursors[idx].left - 2
    110         self.rgbSelectedSlider.SetValue(self.rgbDivs[idx])
    111 
    112     def MoveRGBCursor(self, idx, position):
    113         self.rgbDivs[idx] = position
    114         if 'rgbCursorCont' not in self.__dict__:
    115             return
    116         self.rgbCursorCont.children[idx].left = int(self.rgbCursorCont.GetAbsoluteSize()[0] * position) - 4
    117         self.UpdateGradientData({'rgbDivs': self.rgbDivs})
    118 
    119     def RGBCursor(self, idx, colourComponent, value):
    120         if 'rgbCursorCont' not in self.__dict__:
    121             return
    122         self.rgbPoints[idx][colourComponent] = value
    123         self.UpdateGradientData({'rgbPoints': self.rgbPoints})
    124 
    125     def CreateAlphaCursors(self):
    126         while len(self.alphaCursorCont.children) > 0:
    127             self.alphaCursorCont.children.remove(self.alphaCursorCont.children[0])
    128 
    129         width = self.alphaCursorCont.GetAbsoluteSize()[0] - 8
    130         self.alphaCursors = map(lambda loc: Container(parent=self.alphaCursorCont, align=uiconst.BOTTOMLEFT, width=10, height=16, top=2, left=int(width * loc)), self.alphaDivs)
    131         for i, (s, val) in enumerate(zip(self.alphaCursors, self.alphaPoints)):
    132             middle = Sprite(parent=s, align=uiconst.BOTTOMLEFT, color=(val, val, val), width=6, height=12, top=2, left=2, spriteEffect=trinity.TR2_SFX_FILL)
    133             Sprite(parent=s, align=uiconst.BOTTOMLEFT, width=10, height=16, color=(0.5, 0.5, 0.5), spriteEffect=trinity.TR2_SFX_FILL)
    134 
    135             def fake(slf, idx):
    136 
    137                 def inner(*args):
    138                     slf.SelectAlphaCursor(idx)
    139 
    140                 return inner
    141 
    142             middle.OnMouseDown = fake(self, i)
    143 
    144         self.alphaCursorSelectedSprite = Sprite(parent=self.alphaCursorCont, align=uiconst.BOTTOMLEFT, color=(1.0, 1.0, 1.0), width=14, height=20, left=int(width * self.alphaDivs[self.alphaSelected]) - 2, spriteEffect=trinity.TR2_SFX_FILL)
    145 
    146     def CreateRGBCursors(self):
    147         while len(self.rgbCursorCont.children) > 0:
    148             self.rgbCursorCont.children.remove(self.rgbCursorCont.children[0])
    149 
    150         width = self.rgbCursorCont.GetAbsoluteSize()[0] - 8
    151         self.rgbCursors = map(lambda loc: Container(parent=self.rgbCursorCont, align=uiconst.BOTTOMLEFT, width=10, height=16, top=2, left=int(width * loc)), self.rgbDivs)
    152         for i, (s, val) in enumerate(zip(self.rgbCursors, self.rgbPoints)):
    153             middle = Sprite(parent=s, align=uiconst.BOTTOMLEFT, color=tuple(val), width=6, height=12, top=2, left=2, spriteEffect=trinity.TR2_SFX_FILL)
    154             Sprite(parent=s, align=uiconst.BOTTOMLEFT, width=10, height=16, color=(0.5, 0.5, 0.5), spriteEffect=trinity.TR2_SFX_FILL)
    155 
    156             def fake(slf, idx):
    157 
    158                 def inner(*args):
    159                     slf.SelectRGBCursor(idx)
    160 
    161                 return inner
    162 
    163             middle.OnMouseDown = fake(self, i)
    164 
    165         self.rgbCursorSelectedSprite = Sprite(parent=self.rgbCursorCont, align=uiconst.BOTTOMLEFT, color=(1.0, 1.0, 1.0), width=14, height=20, left=int(width * self.rgbDivs[self.rgbSelected]) - 2, spriteEffect=trinity.TR2_SFX_FILL)
    166 
    167     def AddRGBPoint(self, index):
    168         if index >= len(self.rgbPoints):
    169             self.rgbPoints.append(self.rgbPoints[-1])
    170             self.rgbDivs.append(1.0)
    171             self.SelectRGBCursor(len(self.rgbDivs) - 1)
    172         elif index < 0:
    173             self.rgbPoints.insert(0, self.rgbPoints[0])
    174             self.rgbDivs.insert(0, 0.0)
    175             self.rgbSelected = 0
    176             self.SelectRGBCursor(0)
    177         else:
    178             value = self.rgbPoints[index]
    179             location = self.rgbDivs[index]
    180             if index < len(self.rgbPoints) - 1:
    181                 value = map(lambda x_y: (x_y[0] + x_y[1]) * 0.5, zip(value, self.rgbPoints[index + 1]))
    182                 location = 0.5 * (location + self.rgbDivs[index + 1])
    183                 self.rgbDivs.insert(index + 1, location)
    184                 self.rgbPoints.insert(index + 1, value)
    185                 self.SelectRGBCursor(index + 1)
    186             elif index > 0:
    187                 value = map(lambda x_y1: (x_y1[0] + x_y1[1]) * 0.5, zip(value, self.rgbPoints[index - 1]))
    188                 location = 0.5 * (location + self.rgbDivs[index - 1])
    189                 self.rgbDivs.insert(index, location)
    190                 self.rgbPoints.insert(index, value)
    191                 self.SelectRGBCursor(index)
    192             else:
    193                 self.rgbDivs.insert(index, location)
    194                 self.rgbPoints.insert(index, value)
    195                 self.SelectRGBCursor(index)
    196         self.CreateRGBCursors()
    197         self.UpdateGradientData({'rgbPoints': self.rgbPoints,
    198          'rgbDivs': self.rgbDivs})
    199 
    200     def AddAlphaPoint(self, index):
    201         if index >= len(self.rgbPoints):
    202             self.alphaPoints.append(self.alphaPoints[-1])
    203             self.alphaDivs.append(1.0)
    204             self.SelectAlphaCursor(len(self.alphaDivs) - 1)
    205         elif index < 0:
    206             self.alphaPoints.insert(0, self.alphaPoints[0])
    207             self.alphaDivs.insert(0, 0.0)
    208             self.SelectAlphaCursor(0)
    209         else:
    210             value = self.alphaPoints[index]
    211             location = self.alphaDivs[index]
    212             if index < len(self.alphaPoints) - 1:
    213                 value = 0.5 * (value + self.alphaPoints[index + 1])
    214                 location = 0.5 * (location + self.alphaDivs[index + 1])
    215                 self.alphaDivs.insert(index + 1, location)
    216                 self.alphaPoints.insert(index + 1, value)
    217                 self.SelectAlphaCursor(index + 1)
    218             elif index > 0:
    219                 value = 0.5 * (value + self.alphaPoints[index - 1])
    220                 location = 0.5 * (location + self.alphaDivs[index - 1])
    221                 self.alphaDivs.insert(index, location)
    222                 self.alphaPoints.insert(index, value)
    223                 self.SelectAlphaCursor(index)
    224             else:
    225                 self.alphaDivs.insert(index, location)
    226                 self.alphaPoints.insert(index, location)
    227                 self.SelectAlphaCursor(index + 1)
    228         self.CreateAlphaCursors()
    229         self.UpdateGradientData({'alphaPoints': self.alphaPoints,
    230          'alphaDivs': self.alphaDivs})
    231 
    232     def DeleteRGBPoint(self, index):
    233         if len(self.rgbPoints) <= 1:
    234             return
    235         if index < 0 or index >= len(self.rgbPoints):
    236             return
    237         self.rgbPoints = self.rgbPoints[:index] + self.rgbPoints[index + 1:]
    238         self.rgbDivs = self.rgbDivs[:index] + self.rgbDivs[index + 1:]
    239         self.CreateRGBCursors()
    240         self.UpdateGradientData({'rgbPoints': self.rgbPoints,
    241          'rgbDivs': self.rgbDivs})
    242 
    243     def DeleteAlphaPoint(self, index):
    244         if len(self.alphaPoints) <= 1:
    245             return
    246         if index < 0 or index >= len(self.alphaPoints):
    247             return
    248         self.alphaPoints = self.alphaPoints[:index] + self.alphaPoints[index + 1:]
    249         self.alphaDivs = self.alphaDivs[:index] + self.alphaDivs[index + 1:]
    250         self.CreateAlphaCursors()
    251         self.UpdateGradientData({'alphaPoints': self.alphaPoints,
    252          'alphaDivs': self.alphaDivs})
    253 
    254     def RemoveRGBPoint(self, location):
    255         if len(self.rgbPoints) <= 1:
    256             return
    257         if location >= 1.0:
    258             self.rgbPoints = self.rgbPoints[:-1]
    259             self.rgbDivs = self.rgbDivs[:-1]
    260         elif location <= 0.0:
    261             self.rgbPoints = self.rgbPoints[1:]
    262             self.rgbDivs = self.rgbDivs[1:]
    263         else:
    264             best = 10000
    265             loc = 0.0
    266             idx = 0
    267             for i, k in enumerate(self.rgbDivs):
    268                 dist = abs(k - location)
    269                 if dist < best:
    270                     best = dist
    271                     idx = i
    272                     loc = k
    273 
    274             self.rgbPoints.remove(self.rgbPoints[idx])
    275             self.rgbDivs.remove(loc)
    276         self.UpdateGradientData({'rgbPoints': self.rgbPoints,
    277          'rgbDivs': self.rgbDivs})
    278 
    279     def UpdateGradientData(self, data):
    280         self.gradientData.update(data)
    281         self.UpdateGradientPreview()
    282 
    283     def UpdateGradientPreview(self):
    284         radial = False
    285         if hasattr(self, 'radialCheck'):
    286             radial = self.radialCheck.checked
    287         self.CreateRGBCursors()
    288         self.CreateAlphaCursors()
    289         dataStr = str(self.gradientData)
    290         if radial:
    291             self.gradientPreview.SetTexturePath('dynamic:/gradient_radial/' + dataStr)
    292         else:
    293             self.gradientPreview.SetTexturePath('dynamic:/gradient/' + dataStr)
    294 
    295     def OnResize_(self, *args):
    296         Window.OnResize_(self, *args)
    297         if hasattr(self, 'rgbCursorCont'):
    298             self.CreateRGBCursors()
    299         if hasattr(self, 'alphaCursorCont'):
    300             self.CreateAlphaCursors()
    301 
    302     def SpriteConstructorText(self):
    303         interp = {'linear': 'GradientConst.INTERP_LINEAR',
    304          'cosine': 'GradientConst.INTERP_COSINE',
    305          'bezier': 'GradientConst.INTERP_BEZIER'}
    306         dataWithDefaults = {'rgbDivs': [0.0, 1.0],
    307          'rgbPoints': [(1.0, 0.0, 0.0), (0.0, 1.0, 1.0)],
    308          'alphaDivs': [0.0, 1.0],
    309          'alphaPoints': [1.0, 1.0],
    310          'alphaInterp': 'linear',
    311          'rgbInterp': 'linear'}
    312         dataWithDefaults.update(self.gradientData)
    313         text = 'GradientSprite(\n'
    314         text += '\tparent = uicore.desktop, \n'
    315         text += '\tpos = (0, 0, 256, 256), \n'
    316         text += '\trgbData = ' + str(zip(dataWithDefaults['rgbDivs'], map(tuple, dataWithDefaults['rgbPoints']))) + ', \n'
    317         text += '\talphaData = ' + str(zip(dataWithDefaults['alphaDivs'], dataWithDefaults['alphaPoints'])) + ', \n'
    318         text += '\talphaInterp = ' + interp[dataWithDefaults['alphaInterp']] + ', \n'
    319         text += '\tcolorInterp = ' + interp[dataWithDefaults['rgbInterp']]
    320         if self.radialCheck.checked:
    321             text += ', \n\tradial = True, \n'
    322             text += '\ttoCorners =' + str(dataWithDefaults.get('toCorners', False))
    323         text += '\n\t)'
    324         return text
    325 
    326     def CopyConstructorToClipboard(self, *args):
    327         blue.pyos.SetClipboardData(self.SpriteConstructorText())