home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pyos2bin.zip / Demo / sgi / video / VcrIndex.py < prev    next >
Text File  |  1993-12-17  |  7KB  |  328 lines
  1. #
  2. # A VCR index.
  3. #
  4. import os
  5. import string
  6.  
  7. error='VcrIndex.error'
  8. VERSION_STRING='#!VcrIndex 1.1\n'
  9. PREV_VERSION_STRING='#!VcrIndex 1.0\n'
  10.  
  11. class VcrIndex:
  12.     def __init__(self, name):
  13.         self.curmovie = None
  14.         self.curscene = None
  15.         self.modified = 0
  16.         self.filename = name
  17.         self.basename = os.path.basename(name)
  18.         self.editable = []
  19.         if not name:
  20.             self.movies = {}
  21.             return
  22.         try:
  23.             fp = open(name, 'r')
  24.         except IOError:
  25.             self.movies = {}
  26.             return
  27.         header = fp.readline()
  28.         if header == PREV_VERSION_STRING:
  29.             print 'Converting old-format database...'
  30.             data = fp.read(100000)
  31.             self.movies = eval(data)
  32.             for m in self.movies.keys():
  33.                 d = self.movies[m]
  34.                 newd = {}
  35.                 for s in d.keys():
  36.                     newsd = {}
  37.                     newsd['START'] = d[s]
  38.                     if s == 'START':
  39.                         s = '-ALL-'
  40.                     newd[s] = newsd
  41.                 
  42.                 self.movies[m] = newd
  43.             print 'Done.'
  44.             return
  45.         if header <> VERSION_STRING:
  46.             print 'VcrIndex: incorrect version string:', header
  47.             self.movies = {}
  48.             return
  49.         data = fp.read(100000)
  50.         self.movies = eval(data)
  51.     #
  52.     # Save database to given file (or same file as read from if no
  53.     # filename given).
  54.     # 
  55.     def save(self, name):
  56.         if not name:
  57.             name = self.filename
  58.         if not name:
  59.             raise error, 'No filename given'
  60.         self.filename = name
  61.         bupname = name + '~'
  62.         try:
  63.             os.unlink(bupname)
  64.         except os.error:
  65.             pass
  66.         try:
  67.             os.rename(name, bupname)
  68.         except os.error:
  69.             pass
  70.         fp = open(name, 'w')
  71.         data = str(self.movies)
  72.         fp.write(VERSION_STRING)
  73.         fp.write(data)
  74.         fp.write('\n')
  75.         fp.close()
  76.         self.modified = 0
  77.     #
  78.     # Get a list of movie names in tape order
  79.     #
  80.     def get_movienames(self):
  81.         names = self.movies.keys()
  82.         sorted = []
  83.         for name in names:
  84.             sorted.append(self.movies[name]['-ALL-']['START'], name)
  85.         sorted.sort()
  86.         rv = []
  87.         for pos, name in sorted:
  88.             rv.append(name)
  89.         return rv
  90.     #
  91.     # Get a list of scene names in tape order
  92.     #
  93.     def get_scenenames(self):
  94.         if not self.curmovie:
  95.             return []
  96.         scenedict = self.movies[self.curmovie]
  97.         names = scenedict.keys()
  98.         sorted = []
  99.         for name in names:
  100.             sorted.append(scenedict[name], name)
  101.         sorted.sort()
  102.         rv = []
  103.         for pos, name in sorted:
  104.             rv.append(name)
  105.         return rv
  106.     #
  107.     # Get a list of scene ids (format '00:02:32:12 name') in tape order
  108.     #
  109.     def get_sceneids(self):
  110.         if not self.curmovie:
  111.             return []
  112.         scenedict = self.movies[self.curmovie]
  113.         names = scenedict.keys()
  114.         sorted = []
  115.         for name in names:
  116.             sorted.append(scenedict[name]['START'], name)
  117.         sorted.sort()
  118.         rv = []
  119.         for pos, name in sorted:
  120.             str = '%02d:%02d:%02d:%02d ' % pos
  121.             rv.append(str + name)
  122.         return rv
  123.     #
  124.     # Does a movie exist?
  125.     #
  126.     def movie_exists(self, name):
  127.         return self.movies.has_key(name)
  128.     #
  129.     # Select a movie.
  130.     #
  131.     def movie_select(self, name):
  132.         if not self.movies.has_key(name):
  133.             raise error, 'No such movie: '+name
  134.         self.curmovie = name
  135.         self.curscene = None
  136.     #
  137.     # Get movie dictionary, or raise an error if no current movie.
  138.     #
  139.     def _getmoviedict(self):
  140.         if not self.curmovie:
  141.             raise error, 'No current movie'
  142.         return self.movies[self.curmovie]
  143.     #
  144.     # Rename a movie.
  145.     #
  146.     def movie_rename(self, newname):
  147.         scenedict = self._getmoviedict()
  148.         if self.movie_exists(newname):
  149.             raise error, 'Movie already exists: '+newname
  150.         del self.movies[self.curmovie]
  151.         self.movies[newname] = scenedict
  152.         self.curmovie = newname
  153.         self.modified = 1
  154.     #
  155.     # Copy a movie.
  156.     #
  157.     def movie_copy(self, newname):
  158.         scenedict = self._getmoviedict()
  159.         if self.movie_exists(newname):
  160.             raise error, 'Movie already exists: '+newname
  161.         newdict = {}
  162.         for k in scenedict.keys():
  163.             olddata = scenedict[k]
  164.             newdata = {}
  165.             for i in olddata.keys():
  166.                 newdata[i] = olddata[i]
  167.             newdict[k] = newdata
  168.         self.movies[newname] = newdict
  169.         self.curmovie = newname
  170.         self.modified = 1
  171.     #
  172.     # Delete a movie.
  173.     #
  174.     def movie_delete(self):
  175.         if not self.curmovie:
  176.             raise error, 'No current movie'
  177.         del self.movies[self.curmovie]
  178.         self.curmovie = None
  179.         self.curscene = None
  180.         self.modified = 1
  181.     #
  182.     # Create a new movie.
  183.     #
  184.     def movie_new(self, name, pos):
  185.         if self.movie_exists(name):
  186.             raise error, 'Movie already exists: '+name
  187.         newdict = {}
  188.         newsdict = {}
  189.         newsdict['START'] = pos
  190.         newdict['-ALL-'] = newsdict
  191.         self.movies[name] = newdict
  192.         self.curmovie = name
  193.         self.curscene = None
  194.         self.modified = 1
  195.     #
  196.     # Does a scene exist?
  197.     #
  198.     def scene_exists(self, name):
  199.         scenedict = self._getmoviedict()
  200.         return scenedict.has_key(name)
  201.     #
  202.     # Select a current scene.
  203.     #
  204.     def scene_select(self, name):
  205.         scenedict = self._getmoviedict()
  206.         if not scenedict.has_key(name):
  207.             raise error, 'No such scene: '+name
  208.         self.curscene = name
  209.     #
  210.     # Rename a scene.
  211.     #
  212.     def scene_rename(self, newname):
  213.         scenedict = self._getmoviedict()
  214.         if not self.curscene:
  215.             raise error, 'No current scene'
  216.         if scenedict.has_key(newname):
  217.             raise error, 'Scene already exists: '+newname
  218.         if self.curscene == '-ALL-':
  219.             raise error, 'Cannot rename -ALL-'
  220.         scenedict[newname] = scenedict[self.curscene]
  221.         del scenedict[self.curscene]
  222.         self.curscene = newname
  223.         self.modified = 1
  224.     #
  225.     # Copy a scene.
  226.     #
  227.     def scene_copy(self, newname):
  228.         scenedict = self._getmoviedict()
  229.         if not self.curscene:
  230.             raise error, 'No current scene'
  231.         if scenedict.has_key(newname):
  232.             raise error, 'Scene already exists: '+newname
  233.         scenedict[newname] = scenedict[self.curscene]
  234.         self.curscene = newname
  235.         self.modified = 1
  236.     #
  237.     # Delete a scene.
  238.     #
  239.     def scene_delete(self):
  240.         scenedict = self._getmoviedict()
  241.         if not self.curscene:
  242.             raise error, 'No current scene'
  243.         if self.curscene == '-ALL-':
  244.             raise error, 'Cannot delete -ALL-'
  245.         del scenedict[self.curscene]
  246.         self.curscene = None
  247.         self.modified = 1
  248.     #
  249.     # Add a new scene.
  250.     #
  251.     def scene_new(self, newname, pos):
  252.         scenedict = self._getmoviedict()
  253.         if scenedict.has_key(newname):
  254.             raise error, 'Scene already exists: '+newname
  255.         newdict = {}
  256.         newdict['START'] = pos
  257.         scenedict[newname] = newdict
  258.         self.curscene = newname
  259.         self.modified = 1
  260.     #
  261.     # Get scene data.
  262.     #
  263.     def _getscenedata(self):
  264.         scenedict = self._getmoviedict()
  265.         if not self.curscene:
  266.             raise error, 'No current scene'
  267.         return scenedict[self.curscene]
  268.     #
  269.     # Data manipulation routines.
  270.     #
  271.     def pos_get(self):
  272.         return self._getscenedata()['START']
  273.     #
  274.     def pos_set(self, pos):
  275.         data = self._getscenedata()
  276.         data['START'] = pos
  277.         self.modified = 1
  278.     #
  279.     def comment_get(self):
  280.         data = self._getscenedata()
  281.         if data.has_key('COMMENT'):
  282.             return data['COMMENT']
  283.         else:
  284.             return ''
  285.     #
  286.     def comment_set(self, comment):
  287.         data = self._getscenedata()
  288.         data['COMMENT'] = comment
  289.         self.modified = 1
  290.     #
  291.     # Get the scene id of the current scene.
  292.     #
  293.     def get_cursceneid(self):
  294.         pos = self._getscenedata()['START']
  295.         str = '%02d:%02d:%02d:%02d ' % pos
  296.         return str + self.curscene
  297.     #
  298.     # Convert a scene id to a scene name.
  299.     #
  300.     def scene_id2name(self, id):
  301.         pos = string.find(id, ' ')
  302.         if pos <= 0:
  303.             raise error, 'Not a scene id: '+id
  304.         return id[pos+1:]
  305.     #
  306.     # Select a scene given a position.
  307.     #
  308.     def pos_select(self, pos):
  309.         prevmovie = None
  310.         movies = self.get_movienames()
  311.         for movie in movies:
  312.             mpos = self.movies[movie]['-ALL-']['START']
  313.             if mpos > pos:
  314.                 break
  315.             prevmovie = movie
  316.         if not prevmovie:
  317.             raise error, 'Scene before BOT'
  318.             
  319.         self.movie_select(prevmovie)
  320.         scenes = self.get_scenenames()
  321.         scenedict = self._getmoviedict()
  322.         prevscene = 'START'
  323.         for scene in scenes:
  324.             if scenedict[scene]['START'] > pos:
  325.                 break
  326.             prevscene = scene
  327.         self.scene_select(prevscene)
  328.