Returns the alternate color for this node when it is disabled.
        
        :return     <QColor>
436641
def disabledAlternateColor(self):
        
        palette = self.palette()
        return palette.color(palette.Disabled, palette.NodeAlternateBackground)
866175
def colors(self, p_hint_possible=True):
        
        lookup = {
            'false': 0,
            'no': 0,
            '0': 0,
            '1': 16,
            'true': 16,
            'yes': 16,
            '16': 16,
            '256': 256,
        }

        try:
            forced = self.cp.get('topydo', 'force_colors') == '1'
        except ValueError:
            forced = self.defaults['topydo']['force_colors'] == '1'

        try:
            colors = lookup[self.cp.get('topydo', 'colors').lower()]  # pylint: disable=no-member
        except ValueError:
            colors = lookup[self.defaults['topydo']['colors'].lower()]  # pylint: disable=no-member
        except KeyError:
            # for invalid values or 'auto'
            colors = 16 if p_hint_possible else 0

        # disable colors when no colors are enforced on the commandline and
        # color support is determined automatically
        return 0 if not forced and not p_hint_possible else colors
492074
function getDisplayColor() {
        $colorRole = $this->getColorRole();
        if($colorRole !== null && $colorRole->color > 0) {
            return $colorRole->color;
        }
        
        return null;
    }
596635
public Color getCommonArrowColors(CommonControlState type) {
        switch (type) {

        case DISABLED:
            return arrowDisabled;

        case ENABLED:
        case PRESSED:
            return arrowEnabled;
        }

        return null;
    }
946881
def color(self):
        """"""
        return (self.get_value(CONST.STATUSES_KEY).get('hue'),
                self.get_value(CONST.STATUSES_KEY).get('saturation'))
855893
private int getSrcColor(int x, int y) {
        int argb = srcColorModel.getRGB(srcRaster.getDataElements(x, y, null));
        if (transparency == Transparency.OPAQUE) {
            argb = 0xff000000 | argb;
        }

        return argb;
    }
1059360
private TwoColors getRootPaneInteriorColors(Which type) {
        switch (type) {

        case BACKGROUND_ENABLED_WINDOWFOCUSED:
            return rootPaneActive;

        case BACKGROUND_ENABLED:
            return rootPaneInactive;
        }

        return null;
    }
31845
def add_color(node, key = nil)
      key ||= node.expr.to_s

      self.colors[key] ||= { :variables => [], :alternate_values => [] }
      self.colors[key][:variables] << node.name

      self.colors[key][:alternate_values] |= ([node.expr.to_sass, node.expr.inspect] - [key])
    end
770659
def _default_next_colour(particle):
        
        return particle.colours[
            (len(particle.colours) - 1) * particle.time // particle.life_time]
1240913
protected int getColor(Node node)
	{
		if (!colors.containsKey(node))
		{
			// Absence of color is interpreted as white
			return WHITE;
		}
		else
		{
			return colors.get(node);
		}
	}
963396
def contains_opposite_color_piece(self, square, position):
        
        return not position.is_square_empty(square) and \
            position.piece_at_square(square).color != self.color
1327080
def highlightByAlternate(self):
        
        palette = QtGui.QApplication.palette()
        palette.setColor(palette.HighlightedText, palette.color(palette.Text))
        
        clr = palette.color(palette.AlternateBase)
        palette.setColor(palette.Highlight, clr.darker(110))
        self.setPalette(palette)
400211
def color_for_level(level):
    
    if not color_available:
        return None

    return {
        logging.DEBUG: colorama.Fore.WHITE,
        logging.INFO: colorama.Fore.BLUE,
        logging.WARNING: colorama.Fore.YELLOW,
        logging.ERROR: colorama.Fore.RED,
        logging.CRITICAL: colorama.Fore.MAGENTA
    }.get(level, colorama.Fore.WHITE)
101375
def _get_color(self, color):
        
        qcolor = QtGui.QColor()
        qcolor.setRgb(int(color[:2], base=16),
                      int(color[2:4], base=16),
                      int(color[4:6], base=16))
        return qcolor
9270
def setDisabledPenColor(self, color):
        
        color = QColor(color)
        if self._palette is None:
            self._palette = XNodePalette(self._scenePalette)
        
        self._palette.setColor(self._palette.Disabled,
                               self._palette.NodeForeground,
                               color)
        self.setDirty()
975768
def background(self):
        
        if self._color or not self.editor:
            return self._color
        else:
            return drift_color(self.editor.background, 110)
114338
def background_color(self, value):
        

        if value is not None:
            assert type(value) is QColor, "'{0}' attribute: '{1}' type is not 'QColor'!".format(
                "background_color", value)
        self.__background_color = value