Replies the default color for map elements.

@return the default color for map elements.
351407
@Pure
	public static int getPreferredColor() {
		final Preferences prefs = Preferences.userNodeForPackage(MapElementConstants.class);
		if (prefs != null) {
			return prefs.getInt("COLOR", DEFAULT_COLOR); //$NON-NLS-1$
		}
		return DEFAULT_COLOR;
	}
465178
public Map<String, CellStyle> getCellStyleMapping() {
        if (this.cellStyleMapping == null) {
            this.cellStyleMapping = new HashMap<String, CellStyle>(16);
        }
        return cellStyleMapping;
    }
1158688
protected IColor getColor(int position)
    {
        int defaultColorsSize = DEFAULT_SLICE_COLORS.length;

        if (position < defaultColorsSize)
        {
            return DEFAULT_SLICE_COLORS[position];
        }
        return new Color(position * 20, 128, 0);
    }
745163
public static final String getRandomHexColor()
    {
        final int r = randomRGB();

        final int g = randomRGB();

        final int b = randomRGB();

        return rgbToBrowserHexColor(r, g, b);
    }
346198
function getElementColor () {
    var items = self.options && self.options.colorElement ? self.options.colorElement : [];
    var elem =  items.length ? items[ 0 ] : self.$element[ 0 ];

    return elem ? self.$window.getComputedStyle(elem).color : 'rgb(0,0,0)';
  }
1312695
public function getContrastColor()
    {
        // if there is a code...
        if (!is_null($this->XTermCode)) {

            // check to see if the code is in the array of colors that need white
            if (in_array($this->XTermCode,Colors::$needsWhite256)) {

                // return a new copy of the color object initialized to white
                return new self("white");

            // then it needs black
            } else {

                // return a new copy of the color object initialized to black
                return new self("black");
            }

        // the code is null
        } else {

            // return black as a default
            return new self("black");

        }
        
    }
135830
private Style getStyle() {
        SharedPreferences sharedPreferences =
                PreferenceManager.getDefaultSharedPreferences(getActivity());
        String key = getString(R.string.bottom_sheet_style_preference_key);
        String defaultValue = getString(R.string.bottom_sheet_style_preference_default_value);
        String style = sharedPreferences.getString(key, defaultValue);

        switch (style) {
            case "list":
                return Style.LIST;
            case "list_columns":
                return Style.LIST_COLUMNS;
            default:
                return Style.GRID;
        }
    }
836328
function getNewDefaultRenderer(map) {
        switch (map.orientation) {
            case "orthogonal":
                return new me.TMXOrthogonalRenderer(map);

            case "isometric":
                return new me.TMXIsometricRenderer(map);

            case "hexagonal":
                return new me.TMXHexagonalRenderer(map);

            case "staggered":
                return new me.TMXStaggeredRenderer(map);

            // if none found, throw an exception
            default:
                throw new Error(map.orientation + " type TMX Tile Map not supported!");
        }
    }
1147263
public static int color(ColorHolder colorHolder, Context ctx, @AttrRes int colorStyle, @ColorRes int colorDefault) {
        if (colorHolder == null) {
            return UIUtils.getThemeColorFromAttrOrRes(ctx, colorStyle, colorDefault);
        } else {
            return colorHolder.color(ctx, colorStyle, colorDefault);
        }
    }
148708
public int color(Context ctx) {
        if (mColorInt == 0 && mColorRes != -1) {
            mColorInt = ContextCompat.getColor(ctx, mColorRes);
        }
        return mColorInt;
    }
495375
private void obtainNavigationDividerColor() {
        int color;

        try {
            color = ThemeUtil.getColor(this, R.attr.navigationDividerColor);
        } catch (NotFoundException e) {
            color = ContextCompat.getColor(this, R.color.preference_divider_color_light);
        }

        setNavigationDividerColor(color);
    }
1129746
@Override
    public Color getColor( final String     key,
                           final Color      defaultValue )
    {
        return formatColor( key, getFormattedPropValue( key ), defaultValue );
    }
866023
@Override
	public MapColor getMapColor(Block block, IBlockState state, IBlockAccess world, BlockPos pos)
	{
		return MapColor.getBlockColor(state.getValue(getProperty()));
	}
885630
public static MappingRules getDefaultJsonMapping() {
        return new MappingRules(MappingRules.getDefaultMappingRules().MAPPING_NODE_FILTER,
                MappingRules.MAPPING_EXPORT_FILTER, MappingRules.MAPPING_IMPORT_FILTER,
                new MappingRules.PropertyFormat(MappingRules.PropertyFormat.Scope.definition,
                        MappingRules.PropertyFormat.Binary.link),
                0, MappingRules.ChangeRule.update);
    }
242499
public int color(Context ctx, @AttrRes int colorStyle, @ColorRes int colorDefaultRes) {
        //get the color from the holder else from the theme
        int color = color(ctx);
        if (color == 0) {
            return UIUtils.getThemeColorFromAttrOrRes(ctx, colorStyle, colorDefaultRes);
        } else {
            return color;
        }
    }
293384
protected int getColor(Context ctx) {
        int color;
        if (this.isEnabled()) {
            color = ColorHolder.color(getTextColor(), ctx, R.attr.material_drawer_primary_text, R.color.material_drawer_primary_text);
        } else {
            color = ColorHolder.color(getDisabledTextColor(), ctx, R.attr.material_drawer_hint_text, R.color.material_drawer_hint_text);
        }
        return color;
    }
994959
public static void setPreferredColor(int color) {
		final Preferences prefs = Preferences.userNodeForPackage(MapElementConstants.class);
		if (prefs != null) {
			prefs.putInt("COLOR", color); //$NON-NLS-1$
			try {
				prefs.flush();
			} catch (BackingStoreException exception) {
				//
			}
		}
	}