self.save()

    def get_levels(self):

        return self.levels

    def no_nonzero(self):

        return (not self.levels.values()) or not (max(self.levels.values()) > 0)

    def __mul__(self, scalar):

        return Submaster("%s*%s" % (self.name, scalar), 

            dict_scale(self.levels, scalar), temporary=1)

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

    def __repr__(self):

        return "<'%s': [%s]>" % (self.name, levels)

    def get_dmx_list(self):

        leveldict = self.get_levels() # gets levels of sub contents

        levels = [0] * 68

        for k, v in leveldict.items():

            if v == 0:

                continue

            try:

                dmxchan = Patch.get_dmx_channel(k) - 1

            except ValueError:

                print "error trying to compute dmx levels for submaster %s" % self.name

        for k in self.levels.keys() + otherlevels.keys():

            keys_set[k] = 1

        all_keys = keys_set.keys()

        xfaded_sub = Submaster("xfade", temporary=1)

        for k in all_keys:

            xfaded_sub.set_level(k, 

                                 linear_fade(self.levels.get(k, 0),

                                             otherlevels.get(k, 0),

                                             amount))

        return xfaded_sub

def linear_fade(start, end, amount):

    """Fades between two floats by an amount.  amount is a float between

    0 and 1.  If amount is 0, it will return the start value.  If it is 1,

    the end value will be returned."""

    level = start + (amount * (end - start))

    return level

def sub_maxes(*subs):

    nonzero_subs = [s for s in subs if not s.no_nonzero()]

    name = "max(%s)" % ", ".join([repr(s) for s in nonzero_subs])

    return Submaster(name,