def loadCode(saveCode):
try:
saveCode = saveCode.split(' ')
orderedCards = OrderedDict(sorted(allCards.items(), key=lambda t: t[0]))
i = 0
cards = bin(int(saveCode[0]))
#Trim binary 0b
cards = cards[2:]
#if there are missing leading digits
while len(cards) < 4:
cards = "0" + cards
while cards:
if cards[0].isdigit():
if int(cards[0]):
card = orderedCards.items()[i]
deck[card[0]] = card[1]
if card[0] in looseCards:
del looseCards[card[0]]
i += 1
cards = cards[1:]
model.name = saveCode[1]
model.char = "char" + saveCode[2]
return True
except:
return False
def upgrade( self ):
warnings = OrderedDict()
do_warn = False
for vn, upgs in self.upgrades.items():
warnings[vn] = []
for u in upgs:
for upg in self.expand(u):
try:
old = self.get_item( upg['old'] )
except:
# OK: deprecated item not found
pass
else:
msg = self.show_keys(upg['old'])
if upg['new']:
msg += ' -> ' + self.show_keys(upg['new'])
else:
upg['new'] = upg['old']
msg += " - " + upg['cvt'].describe()
warnings[vn].append( msg )
do_warn = True
self.del_item( upg['old'] )
if upg['cvt'].describe() != "DELETED (OBSOLETE)":
self.put_item( upg['new'], upg['cvt'].convert(old) )
if do_warn and self.verbose:
print >> sys.stderr, "WARNING: deprecated items were automatically upgraded in '" + self.descr + "':"
for vn,msgs in warnings.items():
for m in msgs:
print >> sys.stderr, " * (" + vn + ")", m
class upgrader( object ):
"""Handles upgrading of deprecated config values."""
def __init__( self, cfg, spec, descr, verbose=True ):
"""Store the config dict to be upgraded if necessary."""
self.cfg = cfg
self.spec = spec
self.descr = descr
self.verbose = verbose
# upgrades must be ordered in case several act on the same item
self.upgrades = OrderedDict()
def deprecate( self, vn, oldkeys, newkeys=None, cvtr=None ):
if vn not in self.upgrades:
self.upgrades[vn] = []
if cvtr is None:
cvtr = converter( lambda x: x, "value unchanged" ) # identity
self.upgrades[vn].append(
{
'old' : oldkeys,
'new' : newkeys,
'cvt' : cvtr
}
)
def obsolete( self, vn, oldkeys, newkeys=None ):
if vn not in self.upgrades:
self.upgrades[vn] = []
cvtr = converter( lambda x: x, "DELETED (OBSOLETE)" ) # identity
self.upgrades[vn].append(
{
'old' : oldkeys,
'new' : newkeys,
'cvt' : cvtr
}
)
def get_item( self, keys ):
item = self.cfg
for key in keys:
item = item[key]
return item
def put_item( self, keys, val ):
item = self.cfg
for key in keys[:-1]:
if key not in item:
item[key] = {}
item = item[key]
item[keys[-1]] = val
def del_item( self, keys ):
item = self.cfg
for key in keys[:-1]:
item = item[key]
del item[keys[-1]]
def show_keys( self, keys ):
return '[' + ']['.join(keys) + ']'
def expand( self, upg ):
"""Expands __MANY__ items."""
if '__MANY__' not in upg['old']:
return [upg]
if upg['old'].count( '__MANY__' ) > 1:
print >> sys.stderr, upg['old']
raise UpgradeError( "Multiple simultaneous __MANY__ not supported" )
exp_upgs = []
pre = []
post = []
many = []
i = -1
okeys = upg['old']
for k in okeys:
i += 1
if k == "__MANY__":
pre = okeys[:i]
post = okeys[i+1:]
tmp = self.spec
for j in pre:
tmp = tmp[j]
many = tmp.keys()
break
if not many:
exp_upgs.append( upg )
else:
i = -1
nkeys = upg['new']
npre = []
npost = []
for k in nkeys:
i += 1
if k == "__MANY__":
npre = nkeys[:i]
npost = nkeys[i+1:]
if not npre or not npost:
raise UpgradeError('ERROR: __MANY__ mismatch')
for m in many:
exp_upgs.append( {
'old' : pre + [m] + post,
'new' : npre + [m] + npost,
'cvt' : upg['cvt']
})
return exp_upgs
def upgrade( self ):
warnings = OrderedDict()
do_warn = False
for vn, upgs in self.upgrades.items():
warnings[vn] = []
for u in upgs:
for upg in self.expand(u):
try:
old = self.get_item( upg['old'] )
except:
# OK: deprecated item not found
pass
else:
msg = self.show_keys(upg['old'])
if upg['new']:
msg += ' -> ' + self.show_keys(upg['new'])
else:
upg['new'] = upg['old']
msg += " - " + upg['cvt'].describe()
warnings[vn].append( msg )
do_warn = True
self.del_item( upg['old'] )
if upg['cvt'].describe() != "DELETED (OBSOLETE)":
self.put_item( upg['new'], upg['cvt'].convert(old) )
if do_warn and self.verbose:
print >> sys.stderr, "WARNING: deprecated items were automatically upgraded in '" + self.descr + "':"
for vn,msgs in warnings.items():
for m in msgs:
print >> sys.stderr, " * (" + vn + ")", m
class shotdata:
def __init__(self, user, part, rootpath):
self.version = '0.02'
self.part = part
self.user = user
self.rootpath = rootpath
self.workingdir = rootpath
self.software = softwareinfo.softwareinfo
self.use = 'houdini'
self.renderdir = 'render'
self.structfile = '.showinfo'
self.lastrundir = ''
self.lastruntask = ''
self.lastrunfile = ''
self.items=[]
self.log = ''
self.showlog=True
self.initStruct()
# struct
def initStruct(self):
self.struct = OrderedDict([
('root', self.rootpath),
('show' , ''),
('work' , 'work'),
# -------------------------------------------------
# these levels could deleted depends on show struct
('seq' , ''),
('scene', ''),
('shot' , ''),
# -------------------------------------------------
('run', 'scenes'),
('task' , ''),
('rev' , '')
])
self.head = 'root'
self.showStruct = set(['seq', 'scene', 'shot'])
self.bypassStruct = ['work','run']
self.printStruct = ['show', 'seq', 'scene', 'shot', 'task', 'rev']
# update
def update(self):
''' update working directory and item list. '''
head = self.head
#self.writeLog(head)
if head == 'root':
self.initStruct()
if head == 'show':
self.updateShow()
self.updateDir()
self.updateItems()
def updateShow(self):
''' reads '.showinfo' file in the show directory, checking it's structure, then delete unused level. '''
structfile = ospath.join(self.rootpath, self.struct['show'], '.showinfo')
self.writeLog("{} imported".format(structfile))
with open(structfile) as f:
read = f.readline()
self.writeLog("reset struct to {}".format(read))
readStruct = set(read.strip('\n').split('/'))
delStruct = self.showStruct - readStruct
if delStruct:
self.writeLog("{} will be deleted".format(" ,".join(delStruct)))
else:
self.writeLog("Nothing will be deleted")
for level in delStruct:
del self.struct[level]
def updateDir(self):
''' Tasks and revs are not a dir, so we have to set our last dir '''
struct = self.struct
dirindex = min(self.currentHeadIndex(), struct.keys().index('run'))
workingdir = ospath.join(*struct.values()[:dirindex+1])
print(workingdir)
if os.path.isdir(workingdir):
self.workingdir = workingdir
else:
raise ValueError("Cannot find working directory : {0}".format(workingdir))
def updateItems(self):
''' update items (files and directories) in current directory'''
items = os.listdir(self.workingdir)
items = self.itemculling(items)
if self.currentHeadIndex() <= self.headIndex('shot'):
items = self.directories(items)
elif self.head == 'run':
items = self.tasks(items)
self.struct['task']=items
elif self.head == 'task':
items = self.revs(items, self.struct['task'])
else:
raise KeyError('head is in a danger area! : {0}'.format(head))
self.items = items
# print
def printMessage(self):
filebox.clearScreen()
print('='*75)
print('Shot Manager V{version}'.format(version=self.version).center(75))
print('user : {0}, part : {1}'.format(self.user, self.part).rjust(75))
print('='*75)
print('{0}'.format(self.workingdir).rjust(75))
for s, v in self.struct.items()[self.headIndex('show'):self.currentHeadIndex()+1]:
if s not in self.bypassStruct:
print('{0: >8} : {1}'.format(s.upper(), v))
print('<{0}>'.format(self.nextHead().upper()))
items = [' : '.join(['{0: >4}'.format(idx+1),val]) for idx,val in enumerate(self.items)]
print('\n'.join(items))
print('-'*75)
if self.showlog and self.log:
print(self.log)
print('-'*75)
print('>>>'),
def printHelp(self):
filebox.clearScreen()
print
print('-'*75)
print('HELP')
print('-'*75)
print('go inside : (num)')
print('go up one level : (..)')
print('go to the top : (/)')
print
print('new item : (new)')
print('ex - (new sc01) or (new task1)')
print
print('open directory : (o) or (open)')
print
print('change software : (use)')
print('if you want to change to maya : (use maya)')
print('if you want to change to max : (use max)')
print('if you want to change to houdini : (use houdini)')
print('-'*75)
print
print('>>> Enter to close help.'),
raw_input()
# action
def action(self, userInput):
u = userInput.strip().lower() # strip and force change to lower string
if (not u) or (u in ['help', '/?', '/help']):
self.printHelp()
elif u in ['q', 'quit', 'exit']:
sys.exit('Bye!')
elif u in ['o', 'open']:
self.opendir()
elif u.startswith('use '):
change, sw = u.split(' ')
self.changesoftware(sw)
elif u.startswith('part '):
self.part = u.split()[1]
elif u.startswith('user '):
self.user = u.split()[1]
elif u.startswith('del '):
item = u.split()[1]
self.delete(item)
elif u.startswith('omit '):
item = u.split()[1]
self.omit(item)
elif u.startswith('new '):
names = u.split()[1:]
for n in names:
print(n)
self.new(n)
elif u.startswith('log '):
if u.split()[1] == 'on':
self.logOn()
elif u.split()[1] == 'off':
self.logOff()
else:
self.writeLog("you can do 'log on' or 'log off'")
elif u=='`':
self.runLastTask()
elif u=='~':
self.runLastFile()
elif u == '.':
pass # Copy directory path to the clipboard
else: # Throw any other input to move(), so they can handle it
self.move(u)
# cull
def itemculling(self, items):
'''Any directory or file starts with . or _ will not display'''
culls = [i for i in items if not (i.startswith('.') or i.startswith('_'))]
return culls
def directories(self, items):
'''It takes current path's items, then only return directories'''
dirs = sorted([i for i in items if ospath.isdir(ospath.join(self.workingdir,i))])
return dirs
def tasks(self, items):
''' check the software we are using, then throw files for other software '''
files = [i for i in items if ospath.isfile(ospath.join(self.workingdir,i))]
validFiles = [] # matched file for software user currently use.
exts = self.software[self.use]['read']
for e in exts:
validFiles += [f for f in files if e in f]
rest = re.compile('[-_.]?v?\d*[.]\w+$')
tasksAndOthers = [rest.sub('', i) for i in validFiles]
tasksAndOthers = sorted(list(set(tasksAndOthers)))
shotpath = self.fileprepath()
tasks = [t[len(shotpath)+1:] for t in tasksAndOthers if t.startswith(shotpath)]
return tasks
def revs(self, items, task):
revs = [i for i in items if i.startswith(task)]
revs = sorted(list(set(revs)))
revs.reverse()
return revs
# head - "head" means "Current Level"
def headIndex(self, head):
return self.struct.keys().index(head)
def currentHeadIndex(self):
return self.headIndex(self.head)
def headShift(self, shift):
self.head = self.struct.keys()[self.currentHeadIndex()+shift]
def currentHead(self):
return self.struct.keys()[self.currentHeadIndex()]
def nextHead(self, head=None):
try:
return self.struct.keys()[self.currentHeadIndex()+1]
except IndexError:
return None
def prevHead(self, head=None):
try:
return self.struct.keys()[self.currentHeadIndex()-1]
except IndexError:
return None
def setHeadData(self, data):
self.struct[self.head]=data
def clearHeadData(self):
self.struct[self.head]=''
# move
def move(self, inputstring):
lowerinput = inputstring.lower()
loweritems = [i.lower() for i in self.items]
if inputstring == '..':
self.up()
elif inputstring == '/':
self.top()
elif inputstring.isdigit():
select = int(inputstring)-1
if 0 <= select < len(self.items):
self.down(self.items[select])
else:
self.writeLog('invalid number : {0}'.format(inputstring))
elif lowerinput in loweritems:
i = loweritems.index(lowerinput)
self.down(self.items[i])
else:
self.writeLog('invalid input : {0}'.format(inputstring))
def top(self):
self.head = 'root'
#self.initStruct()
def up(self):
struct = self.struct
if self.head in self.bypassStruct:
while self.head in self.bypassStruct:
self.headShift(-1)
self.clearHeadData()
if self.head != 'root':
self.headShift(-1)
def down(self, dest):
struct = self.struct
if self.nextHead() == 'task':
self.runTask(self.workingdir, dest)
elif self.nextHead() == 'rev':
self.runRev(dest)
else:
self.headShift(1)
self.setHeadData(dest)
self.update() # there are chances to skip update, so force update
while self.nextHead() in self.bypassStruct:
self.headShift(1)
print(self.head)
# run
def runTask(self, dir, task):
flist = os.listdir(dir)
shot = self.fileprepath()
flist = sorted([f for f in flist if f.startswith(shot+'.'+task)])
flist.reverse()
lastf = flist[0]
lastfpath = ospath.join(self.workingdir, lastf)
self.lastrundir = dir
self.lastruntask = task
self.lastrunfile = lastfpath
os.system('{0} {1}'.format(self.software[self.use]['execute'], lastfpath))
def runFile(self, file):
print(self.use, self.software[self.use])
os.system('{0} {1}'.format(self.software[self.use]['execute'], file))
def runLastTask(self):
if self.lastrundir and self.lastruntask:
self.runTask(self.lastrundir, self.lastruntask)
else:
self.writeLog('Could not find last task! Maybe its your first time to use this program... or not? :)')
def runLastFile(self):
if self.lastrunfile:
self.runFile(self.lastrunfile)
# new
def new(self, name):
nexthead = self.nextHead()
if nexthead in ['show']:
self.newshow(name)
elif nexthead in ['seq', 'scene']:
self.newdir(name)
elif nexthead in ['shot']:
self.newshot(name)
elif nexthead in ['task', 'rev']:
self.newtask(name)
def newdir(self, dirname):
nd = ospath.join(self.workingdir, dirname)
os.mkdir(nd)
def newshow(self, showname):
''' this will make show struct directories and info (.showinfo) file'''
A, B, C = 'seq/scene/shot', 'scene/shot', 'shot'
print('choose one of these types')
print('1. show/' + A)
print('2. show/' + B)
print('3. show/' + C)
userinput = raw_input()
if userinput not in ['1', '2', '3']:
self.log+='intput invalid, please type 1-3'
return
else:
showtype = [A, B, C][int(userinput)-1]
showpath = ospath.join(self.workingdir, showname)
os.mkdir(showpath)
maketree.make('show', showpath)
self.log+=showtype
self.log+=showpath
self.makeShowInfoFile(showtype, showpath)
def makeShowInfoFile(self, showtype, showpath):
showfile = ospath.join(showpath, '.showinfo')
with open(showfile, 'w') as f:
f.write(showtype)
def newshot(self, shot):
path = ospath.join(self.workingdir, shot)
os.mkdir(path)
maketree.make('shot', path)
def newtask(self, taskname):
struct = self.struct
structname = self.structname
structpath = self.structpath
filename = '.'.join([self.fileprepath(), taskname, 'v101', self.software[self.use]['write']])
filepath = ospath.join(self.workingdir, filename)
shotpath = self.shotpath()
renderpath = self.renderpath()
startf, endf, fps = 1, 240, 24.0
initscript = self.software[self.use]['initscript'].format(
show=structname('show'),
seq=structname('seq'),
scene=structname('scene'),
shot=structname('shot'),
task=taskname,
showpath = structpath('show'),
seqpath=structpath('seq'),
scenepath=structpath('scene'),
taskpath=structpath('run'),
shotpath=shotpath,
renderpath=renderpath,
filepath=filepath,
fps=24, start=(startf-1)/fps, end=endf/fps
)
scriptfile = ospath.join(self.workingdir, '.temp_init')
with open(scriptfile, 'w') as f:
f.write(initscript)
command = self.software[self.use]['batch'] + ' ' + scriptfile
# command = self.software[self.use]['batch'].format(filepath=filepath) + ' ' + scriptfile
self.writeLog("running setup script.. : {}".format(command))
os.system(command)
os.remove(scriptfile)
self.runFile(filepath)
# other actions
def opendir(self):
dir = self.workingdir
os.system('thunar {dir}'.format(dir=dir))
def changesoftware(self, sw):
if sw in self.software:
self.use = sw
# self.struct['software'] = self.software[self.use]['dir']
else:
print("there isn't such a software")
def delete(self, item):
''' Move items to '_deleted' directory '''
itempath = ospath.join(self.workingdir, item)
filebox.incBackup(itempath, backupdirname ='_deleted', move=True)
def omit(self, item):
''' Move items to '_omitted' directory '''
itempath = ospath.join(self.workingdir, item)
filebox.incBackup(itempath, backupdirname ='_omitted', move=True)
def writeLog(self, comment):
if self.log:
self.log+='\n'
self.log+="{}".format(comment)
def clearLog(self):
self.log=''
def logOn(self):
self.showlog=True
def logOff(self):
self.showlog=False
# utility
def structname(self, structname):
try:
return self.struct[structname]
except KeyError:
return ''
def structpath(self, structname):
struct = self.struct
try:
idx = struct.keys().index(structname)
except ValueError:
return ''
paths = struct.values()[:idx+1]
structpath = []
for p in paths:
structpath.append(p)
# print(structpath)
return('/'.join(structpath))
def fileprepath(self):
prepath = []
struct = self.struct
showidx, shotidx = struct.keys().index('show'), struct.keys().index('shot')
paths = struct.values()[showidx : shotidx+1]
for p in paths:
if not p in self.bypassStruct:
prepath.append(p)
return('_'.join(prepath))
def shotpath(self):
return self.workingdir.replace(self.software[self.use]['dir'], '').rstrip('/')
def renderpath(self):
return ospath.join(self.shotpath(), self.renderdir)
def printHierachy(self):
hierachy = []
for i in self.printStruct:
if i in self.struct:
hierachy.append((i, self.struct[i]))
return hierachy
class listBox(QListWidget,widgetState):
def __init__(self, widget, value=None, label=None, displayLabel=True, orientation='vertical', selectionMode=QAbstractItemView.SingleSelection, enableDragDrop = 0, dragDropCallback = None, dataValidityCallback = None, sizeHint = None, callback=None, items = None, *args, **kwargs):
kwargs.setdefault('includeInReports', True)
kwargs.setdefault('sizePolicy', QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
widgetState.__init__(self,widget,label,**kwargs)
QListWidget.__init__(self, *args)
self.label = label
self.widget = self.controlArea
if displayLabel:
self.hb = groupBox(self.controlArea,label=label,orientation=orientation)
else:
self.hb = widgetBox(self.controlArea,orientation=orientation)
self.hb.layout().addWidget(self)
self.ogValue = value
self.ogLabels = label
self.enableDragDrop = enableDragDrop
self.dragDopCallback = dragDropCallback
self.dataValidityCallback = dataValidityCallback
self.defaultSizeHint = QSize(150,100)
self.setSelectionMode(selectionMode)
if enableDragDrop:
self.setDragEnabled(1)
self.setAcceptDrops(1)
self.setDropIndicatorShown(1)
#self.setDragDropMode(QAbstractItemView.DragDrop)
self.dragStartPosition = 0
self.listItems = OrderedDict()
if items:
self.addItems(items)
if callback:
QObject.connect(self, SIGNAL('itemClicked(QListWidgetItem*)'), callback)
def getItems(self):
"""Returns an OrderedDict of the items (key, value) in the listBox, this can be treated as a dict also."""
return self.listItems
def addItem(self,id,item):
QListWidget.addItem(self,item)
self.listItems[id] = item
def addItems(self,items):
progressBar = startProgressBar('Setting List Items', '', len(items))
progress = 0
if type(items) in [dict,OrderedDict]:
for k,v in items.items():
self.addItem(k,v)
progress += 1
progressBar.setValue(progress)
elif type(items) in [list]:
progressBar = startProgressBar('Setting List Items', '', len(items))
if len(items) > 0 and type(items[0]) is tuple:
for k,v in items:
self.addItem(k,v)
progress += 1
progressBar.setValue(progress)
else:
for v in items:
self.addItem(v,v)
progress += 1
progressBar.setValue(progress)
# redRLog.log(redRLog.REDRCORE,redRLog.DEBUG,_('In listBox should not use list'))
else:
progressBar.hide()
raise Exception(_('In listBox, addItems takes a list, dict or OrderedDict'))
progressBar.hide()
def setSelectedIds(self,ids):
"""Sets a list of ids (ids) to be selected."""
if ids == None: return
progressBar = startProgressBar('Setting Selected Items', '', len(ids))
progress = 0
for x in ids:
try:
self.item(self.listItems.keys().index(x)).setSelected(True)
except:
pass
progress += 1
progressBar.setValue(progress)
def update(self, items):
"""Clears the list, adds new items, and sets any selected items in the old list to being selected in the new list (if they exist of course)."""
current = self.selectedIds()
self.clear()
self.addItems(items)
self.setSelectedIds(current)
def clear(self):
"""Clears the list"""
QListWidget.clear(self)
self.listItems = OrderedDict()
def invertSelection(self):
for i in range(self.count()):
if self.isItemSelected(self.item(i)):
self.item(i).setSelected(False)
else:
self.item(i).setSelected(True)
def selectionCount(self):
return len(self.selectedIndexes())
def currentSelection(self):
"""Returns a list of selected values (the text in the list)"""
return self.selectedItems().values()
def selectedItems(self):
"""Returns a dict of selected items."""
items = {}
for x in self.selectedIndexes():
items[self.listItems.keys()[x.row()]] = self.listItems.values()[x.row()]
return items
def selectedIds(self):
"""Returns a list of selected ids"""
ids = []
for x in self.selectedIndexes():
ids.append(self.listItems.keys()[x.row()])
return ids
#def setSelectedIds(self, ids):
#if ids == None: return
#for i in range(self.count()):
#if self.listItems.keys()[i] in ids:
#self.item(i).setSelect(True)
def sizeHint(self):
return self.defaultSizeHint
def startDrag(self, supportedActions):
if not self.enableDragDrop: return
drag = QDrag(self)
mime = QMimeData()
if not self.ogValue:
selectedItems = [i for i in range(self.count()) if self.item(i).isSelected()]
else:
selectedItems = getdeepattr(self.widget, self.ogValue, default = [])
mime.setText(unicode(selectedItems))
mime.source = self
drag.setMimeData(mime)
drag.start(Qt.MoveAction)
def dragEnterEvent(self, ev):
if not self.enableDragDrop: return
if self.dataValidityCallback: return self.dataValidityCallback(ev)
if ev.mimeData().hasText():
ev.accept()
else:
ev.ignore()
def dragMoveEvent(self, ev):
if not self.enableDragDrop: return
if self.dataValidityCallback: return self.dataValidityCallback(ev)
if ev.mimeData().hasText():
ev.setDropAction(Qt.MoveAction)
ev.accept()
else:
ev.ignore()
def dropEvent(self, ev):
if not self.enableDragDrop: return
if ev.mimeData().hasText():
item = self.itemAt(ev.pos())
if item:
index = self.indexFromItem(item).row()
else:
index = self.count()
source = ev.mimeData().source
selectedItemIndices = eval(unicode(ev.mimeData().text()))
if self.ogLabels != None and self.ogValue != None:
allSourceItems = getdeepattr(source.widget, source.ogLabels, default = [])
selectedItems = [allSourceItems[i] for i in selectedItemIndices]
allDestItems = getdeepattr(self.widget, self.ogLabels, default = [])
if source != self:
setattr(source.widget, source.ogLabels, [item for item in allSourceItems if item not in selectedItems]) # TODO: optimize this code. use the fact that the selectedItemIndices is a sorted list
setattr(self.widget, self.ogLabels, allDestItems[:index] + selectedItems + allDestItems[index:])
setattr(source.widget, source.ogValue, []) # clear selection in the source widget
else:
items = [item for item in allSourceItems if item not in selectedItems]
if index < len(allDestItems):
while index > 0 and index in getdeepattr(self.widget, self.ogValue, default = []): # if we are dropping items on a selected item, we have to select some previous unselected item as the drop target
index -= 1
destItem = allDestItems[index]
index = items.index(destItem)
else:
index = max(0, index - len(selectedItems))
setattr(self.widget, self.ogLabels, items[:index] + selectedItems + items[index:])
setattr(self.widget, self.ogValue, range(index, index+len(selectedItems)))
else: # if we don't have variables ogValue and ogLabel
if source != self:
self.insertItems(source.selectedItems())
for index in selectedItemIndices[::-1]:
source.takeItem(index)
else:
if index < self.count():
while index > 0 and self.item(index).isSelected(): # if we are dropping items on a selected item, we have to select some previous unselected item as the drop target
index -= 1
items = [source.item(i) for i in selectedItemIndices]
for ind in selectedItemIndices[::-1]:
source.takeItem(ind)
if ind <= index: index-= 1
for item in items[::-1]:
self.insertItem(index, item)
self.clearSelection()
for i in range(index, index+len(items)):
self.item(i).setSelected(1)
if self.dragDopCallback: # call the callback
self.dragDopCallback()
ev.setDropAction(Qt.MoveAction)
ev.accept()
## whatever all of this does we need to execute the function to update the items
self.updateRedRItems()
else:
ev.ignore()
def updateRedRItems(self):
"""Updates the items in the list to a new order."""
## we go through all of the items and remake the items OrderedDict
newDict = OrderedDict()
for r in range(self.count()):
t = unicode(self.item(r).text()) # get the text of the item
if t not in self.listItems.values():
newDict[t] = t
else:
for i, ov in self.listItems.items():
if ov == t:
newDict[i] = ov
self.listItems = newDict
def getSettings(self):
#print 'saving list box'
r = {'items':self.listItems, 'selected':self.selectedIds()}
#print r
return r
def loadSettings(self,data):
self.clear()
self.addItems(data.get('items', []))
self.setSelectedIds(data.get('selected', None))
def getReportText(self, fileDir):
items = self.getItems()
selected = self.currentSelection()
new = []
for x in items:
if x in selected:
new.append([_('Selected'), x])
else:
new.append([_('Not Selected'),x])
#print new
text = redRReports.createTable(new,columnNames=[_('Selection'),_('Option')])
# if text != '':
# text += '\nSelected text has * in front'
r = {self.widgetName:{'includeInReports': self.includeInReports, 'text': text}}
return r
class listBox(QListWidget, widgetState):
def __init__(self,
widget,
value=None,
label=None,
displayLabel=True,
includeInReports=True,
orientation='vertical',
selectionMode=QAbstractItemView.SingleSelection,
enableDragDrop=0,
dragDropCallback=None,
dataValidityCallback=None,
sizeHint=None,
callback=None,
toolTip=None,
items=None,
*args):
widgetState.__init__(self, widget, label, includeInReports)
QListWidget.__init__(self, *args)
self.label = label
self.widget = self.controlArea
if displayLabel:
self.hb = groupBox(self.controlArea,
label=label,
orientation=orientation)
else:
self.hb = widgetBox(self.controlArea, orientation=orientation)
self.hb.layout().addWidget(self)
self.ogValue = value
self.ogLabels = label
self.enableDragDrop = enableDragDrop
self.dragDopCallback = dragDropCallback
self.dataValidityCallback = dataValidityCallback
if not sizeHint:
self.defaultSizeHint = QSize(150, 100)
else:
self.defaultSizeHint = sizeHint
self.setSelectionMode(selectionMode)
if enableDragDrop:
self.setDragEnabled(1)
self.setAcceptDrops(1)
self.setDropIndicatorShown(1)
#self.setDragDropMode(QAbstractItemView.DragDrop)
self.dragStartPosition = 0
if toolTip:
self.setToolTip(toolTip)
self.listItems = OrderedDict()
if items:
self.addItems(items)
if callback:
QObject.connect(self, SIGNAL('itemClicked(QListWidgetItem*)'),
callback)
def getItems(self):
return self.listItems
def addItem(self, id, item):
QListWidget.addItem(self, item)
self.listItems[id] = item
def addItems(self, items):
if type(items) in [dict, OrderedDict]:
for k, v in items.items():
self.addItem(k, v)
elif type(items) in [list]:
if len(items) > 0 and type(items[0]) is tuple:
for k, v in items:
self.addItem(k, v)
else:
for v in items:
self.addItem(v, v)
# redRLog.log(redRLog.REDRCORE,redRLog.DEBUG,_('In listBox should not use list'))
else:
raise Exception(
_('In listBox, addItems takes a list, dict or OrderedDict'))
def setSelectedIds(self, ids):
for x in ids:
try:
self.item(self.listItems.keys().index(x)).setSelected(True)
except:
pass
def update(self, items):
current = self.selectedIds()
self.clear()
self.addItems(items)
self.setSelectedIds(current)
def clear(self):
QListWidget.clear(self)
self.items = OrderedDict()
def invertSelection(self):
for i in range(self.count()):
if self.isItemSelected(self.item(i)):
self.item(i).setSelected(False)
else:
self.item(i).setSelected(True)
def selectionCount(self):
return len(self.selectedIndexes())
def currentSelection(self):
return self.selectedItems().values()
def selectedItems(self):
items = {}
for x in self.selectedIndexes():
items[self.listItems.keys()[x.row()]] = self.listItems.values()[
x.row()]
return items
def selectedIds(self):
ids = []
for x in self.selectedIndexes():
ids.append(self.listItems.keys()[x.row()])
return ids
def sizeHint(self):
return self.defaultSizeHint
def startDrag(self, supportedActions):
if not self.enableDragDrop: return
drag = QDrag(self)
mime = QMimeData()
if not self.ogValue:
selectedItems = [
i for i in range(self.count()) if self.item(i).isSelected()
]
else:
selectedItems = getdeepattr(self.widget, self.ogValue, default=[])
mime.setText(unicode(selectedItems))
mime.source = self
drag.setMimeData(mime)
drag.start(Qt.MoveAction)
def dragEnterEvent(self, ev):
if not self.enableDragDrop: return
if self.dataValidityCallback: return self.dataValidityCallback(ev)
if ev.mimeData().hasText():
ev.accept()
else:
ev.ignore()
def dragMoveEvent(self, ev):
if not self.enableDragDrop: return
if self.dataValidityCallback: return self.dataValidityCallback(ev)
if ev.mimeData().hasText():
ev.setDropAction(Qt.MoveAction)
ev.accept()
else:
ev.ignore()
def dropEvent(self, ev):
if not self.enableDragDrop: return
if ev.mimeData().hasText():
item = self.itemAt(ev.pos())
if item:
index = self.indexFromItem(item).row()
else:
index = self.count()
source = ev.mimeData().source
selectedItemIndices = eval(unicode(ev.mimeData().text()))
if self.ogLabels != None and self.ogValue != None:
allSourceItems = getdeepattr(source.widget,
source.ogLabels,
default=[])
selectedItems = [
allSourceItems[i] for i in selectedItemIndices
]
allDestItems = getdeepattr(self.widget,
self.ogLabels,
default=[])
if source != self:
setattr(
source.widget, source.ogLabels, [
item for item in allSourceItems
if item not in selectedItems
]
) # TODO: optimize this code. use the fact that the selectedItemIndices is a sorted list
setattr(
self.widget, self.ogLabels, allDestItems[:index] +
selectedItems + allDestItems[index:])
setattr(source.widget, source.ogValue,
[]) # clear selection in the source widget
else:
items = [
item for item in allSourceItems
if item not in selectedItems
]
if index < len(allDestItems):
while index > 0 and index in getdeepattr(
self.widget, self.ogValue, default=[]
): # if we are dropping items on a selected item, we have to select some previous unselected item as the drop target
index -= 1
destItem = allDestItems[index]
index = items.index(destItem)
else:
index = max(0, index - len(selectedItems))
setattr(self.widget, self.ogLabels,
items[:index] + selectedItems + items[index:])
setattr(self.widget, self.ogValue,
range(index, index + len(selectedItems)))
else: # if we don't have variables ogValue and ogLabel
if source != self:
self.insertItems(source.selectedItems())
for index in selectedItemIndices[::-1]:
source.takeItem(index)
else:
if index < self.count():
while index > 0 and self.item(index).isSelected(
): # if we are dropping items on a selected item, we have to select some previous unselected item as the drop target
index -= 1
items = [source.item(i) for i in selectedItemIndices]
for ind in selectedItemIndices[::-1]:
source.takeItem(ind)
if ind <= index: index -= 1
for item in items[::-1]:
self.insertItem(index, item)
self.clearSelection()
for i in range(index, index + len(items)):
self.item(i).setSelected(1)
if self.dragDopCallback: # call the callback
self.dragDopCallback()
ev.setDropAction(Qt.MoveAction)
ev.accept()
## whatever all of this does we need to execute the function to update the items
self.updateRedRItems()
else:
ev.ignore()
def updateRedRItems(self):
## we go through all of the items and remake the items OrderedDict
newDict = OrderedDict()
for r in range(self.count()):
t = unicode(self.itemAt(r).text()) # get the text of the item
if t not in self.listItems.values():
newDict[t] = t
else:
for i, ov in self.listItems.items():
if ov == t:
newDict[i] = ov
self.listItems = newDict
def getSettings(self):
print 'saving list box'
r = {'items': self.items, 'selected': self.selectedIds()}
print r
return r
def loadSettings(self, data):
print _('loading list box')
print data
self.clear()
self.addItems(data['items'])
self.setSelectedIds(data['selected'])
def getReportText(self, fileDir):
items = self.getItems()
selected = self.currentSelection()
new = []
for x in items:
if x in selected:
new.append([_('Selected'), x])
else:
new.append([_('Not Selected'), x])
#print new
text = redRReports.createTable(
new, columnNames=[_('Selection'), _('Option')])
# if text != '':
# text += '\nSelected text has * in front'
r = {
self.widgetName: {
'includeInReports': self.includeInReports,
'text': text
}
}
return r
