shuiyu1123
a51854455b
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等) - java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等) - javax/ 4个模块 (net/crypto/security/sql) - org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http) - dalvik/ 1个模块 (system) - ~3053个类/接口，方法签名完全对齐Android SDK - 桌面跨平台运行 (Windows/macOS/Linux) - 修复所有导入错误和Python关键字冲突
668 lines
22 KiB
Python
668 lines
22 KiB
Python
"""
|
|
Android graphics.drawable 扩展 — ShapeDrawable, GradientDrawable, LayerDrawable,
|
|
StateListDrawable, AnimatedVectorDrawable, RippleDrawable 等
|
|
方法签名完全对齐 Android SDK
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sys
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
from .._core import Stub, AndroidOnlyError
|
|
from ..java.lang import RuntimeException
|
|
|
|
IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})
|
|
|
|
__all__ = [
|
|
"ShapeDrawable",
|
|
"PaintDrawable",
|
|
"GradientDrawable",
|
|
"StateListDrawable",
|
|
"LayerDrawable",
|
|
"LevelListDrawable",
|
|
"ScaleDrawable",
|
|
"ClipDrawable",
|
|
"RotateDrawable",
|
|
"TransitionDrawable",
|
|
"AnimatedStateListDrawable",
|
|
"AnimatedImageDrawable",
|
|
"AnimatedVectorDrawable",
|
|
"RippleDrawable",
|
|
"AnimatedRotateDrawable",
|
|
"InsetDrawable",
|
|
"NinePatchDrawable",
|
|
]
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# ShapeDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class ShapeDrawable(Stub):
|
|
"""ShapeDrawable — 形状可绘制对象 (桌面存根)"""
|
|
|
|
def __init__(self, shape: Any = None):
|
|
super().__init__()
|
|
self._shape = shape
|
|
self._paint = None
|
|
self._shader_factory = None
|
|
self._bounds = (0, 0, 0, 0)
|
|
self._alpha = 255
|
|
|
|
def getShape(self) -> Any:
|
|
"""获取形状"""
|
|
return self._shape
|
|
|
|
def setShape(self, shape: Any) -> None:
|
|
"""设置形状"""
|
|
self._shape = shape
|
|
|
|
def getPaint(self) -> Any:
|
|
"""获取画笔"""
|
|
return self._paint
|
|
|
|
def setShaderFactory(self, factory: Any) -> None:
|
|
"""设置着色器工厂"""
|
|
self._shader_factory = factory
|
|
|
|
def getShaderFactory(self) -> Any:
|
|
"""获取着色器工厂"""
|
|
return self._shader_factory
|
|
|
|
def inflate(self, context: Any, attrs: Any) -> None:
|
|
"""从 XML 填充"""
|
|
pass
|
|
|
|
def setAlpha(self, alpha: int) -> None:
|
|
"""设置透明度"""
|
|
self._alpha = alpha
|
|
|
|
def getAlpha(self) -> int:
|
|
"""获取透明度"""
|
|
return self._alpha
|
|
|
|
def setBounds(self, left: int, top: int, right: int, bottom: int) -> None:
|
|
"""设置边界"""
|
|
self._bounds = (left, top, right, bottom)
|
|
|
|
def getIntrinsicWidth(self) -> int:
|
|
"""获取内部宽度"""
|
|
if self._shape and hasattr(self._shape, 'getWidth'):
|
|
return self._shape.getWidth()
|
|
return 0
|
|
|
|
def getIntrinsicHeight(self) -> int:
|
|
"""获取内部高度"""
|
|
if self._shape and hasattr(self._shape, 'getHeight'):
|
|
return self._shape.getHeight()
|
|
return 0
|
|
|
|
|
|
class PaintDrawable(ShapeDrawable):
|
|
"""PaintDrawable — 画笔可绘制对象"""
|
|
|
|
def __init__(self, color: int = 0):
|
|
super().__init__()
|
|
self._color = color
|
|
|
|
def setColor(self, color: int) -> None:
|
|
"""设置颜色"""
|
|
self._color = color
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# GradientDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class GradientDrawable(ShapeDrawable):
|
|
"""GradientDrawable — 渐变可绘制对象"""
|
|
|
|
RECTANGLE = 0
|
|
OVAL = 1
|
|
LINE = 2
|
|
RING = 3
|
|
LINEAR_GRADIENT = 0
|
|
RADIAL_GRADIENT = 1
|
|
SWEEP_GRADIENT = 2
|
|
|
|
def __init__(self, orientation: Any = None, colors: Optional[List[int]] = None):
|
|
super().__init__()
|
|
self._shape_type = GradientDrawable.RECTANGLE
|
|
self._gradient_type = GradientDrawable.LINEAR_GRADIENT
|
|
self._gradient_center = (0.5, 0.5)
|
|
self._corner_radius = 0.0
|
|
self._corner_radii: Optional[List[float]] = None
|
|
self._stroke_width = 0
|
|
self._stroke_color = 0
|
|
self._color = 0
|
|
self._colors = colors or []
|
|
self._orientation = orientation
|
|
self._size = (0, 0)
|
|
|
|
def setShape(self, shape_type: int) -> None:
|
|
"""设置形状类型"""
|
|
self._shape_type = shape_type
|
|
|
|
def setSize(self, width: int, height: int) -> None:
|
|
"""设置尺寸"""
|
|
self._size = (width, height)
|
|
|
|
def setGradientType(self, gradient_type: int) -> None:
|
|
"""设置渐变类型"""
|
|
self._gradient_type = gradient_type
|
|
|
|
def setGradientCenter(self, x: float, y: float) -> None:
|
|
"""设置渐变中心"""
|
|
self._gradient_center = (x, y)
|
|
|
|
def setCornerRadius(self, radius: float) -> None:
|
|
"""设置圆角半径"""
|
|
self._corner_radius = radius
|
|
|
|
def setCornerRadii(self, radii: List[float]) -> None:
|
|
"""设置圆角半径组"""
|
|
self._corner_radii = radii
|
|
|
|
def setStroke(self, width: int, color: int, dash_width: float = 0.0,
|
|
dash_gap: float = 0.0) -> None:
|
|
"""设置描边"""
|
|
self._stroke_width = width
|
|
self._stroke_color = color
|
|
|
|
def setColor(self, color: int) -> None:
|
|
"""设置颜色"""
|
|
self._color = color
|
|
|
|
def getColor(self) -> int:
|
|
"""获取颜色"""
|
|
return self._color
|
|
|
|
def setColors(self, colors: List[int]) -> None:
|
|
"""设置颜色数组"""
|
|
self._colors = colors
|
|
|
|
def getOrientation(self) -> Any:
|
|
"""获取方向"""
|
|
return self._orientation
|
|
|
|
def getIntrinsicWidth(self) -> int:
|
|
return self._size[0]
|
|
|
|
def getIntrinsicHeight(self) -> int:
|
|
return self._size[1]
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# StateListDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class StateListDrawable(ShapeDrawable):
|
|
"""StateListDrawable — 状态列表可绘制对象"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._states: List[Tuple[List[int], Any]] = []
|
|
self._enter_fade_duration = 0
|
|
self._exit_fade_duration = 0
|
|
|
|
def addState(self, state_set: List[int], drawable: Any) -> None:
|
|
"""添加状态"""
|
|
self._states.append((state_set, drawable))
|
|
|
|
def setState(self, state_set: List[int]) -> bool:
|
|
"""设置当前状态"""
|
|
return True
|
|
|
|
def getStateCount(self) -> int:
|
|
"""获取状态数量"""
|
|
return len(self._states)
|
|
|
|
def getStateSet(self, index: int) -> List[int]:
|
|
"""获取指定索引的状态集"""
|
|
if 0 <= index < len(self._states):
|
|
return self._states[index][0]
|
|
return []
|
|
|
|
def getStateDrawable(self, index: int) -> Any:
|
|
"""获取指定索引的可绘制对象"""
|
|
if 0 <= index < len(self._states):
|
|
return self._states[index][1]
|
|
return None
|
|
|
|
def setEnterFadeDuration(self, duration: int) -> None:
|
|
"""设置进入淡出时间"""
|
|
self._enter_fade_duration = duration
|
|
|
|
def setExitFadeDuration(self, duration: int) -> None:
|
|
"""设置退出淡出时间"""
|
|
self._exit_fade_duration = duration
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# LayerDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class LayerDrawable(ShapeDrawable):
|
|
"""LayerDrawable — 图层可绘制对象"""
|
|
|
|
def __init__(self, layers: Optional[List[Any]] = None):
|
|
super().__init__()
|
|
self._layers: List[Any] = layers or []
|
|
self._layer_insets: Dict[int, Tuple[int, int, int, int]] = {}
|
|
self._padding = (0, 0, 0, 0)
|
|
self._id_map: Dict[int, int] = {}
|
|
|
|
def setLayerInset(self, index: int, left: int, top: int, right: int, bottom: int) -> None:
|
|
"""设置图层嵌入"""
|
|
self._layer_insets[index] = (left, top, right, bottom)
|
|
|
|
def setLayerInsetRelative(self, index: int, start: int, top: int, end: int, bottom: int) -> None:
|
|
"""设置相对图层嵌入"""
|
|
self._layer_insets[index] = (start, top, end, bottom)
|
|
|
|
def setDrawable(self, index: int, drawable: Any) -> None:
|
|
"""设置可绘制对象"""
|
|
while len(self._layers) <= index:
|
|
self._layers.append(None)
|
|
self._layers[index] = drawable
|
|
|
|
def setDrawableByLayerId(self, id_: int, drawable: Any) -> bool:
|
|
"""按图层 ID 设置可绘制对象"""
|
|
if id_ in self._id_map:
|
|
idx = self._id_map[id_]
|
|
self._layers[idx] = drawable
|
|
return True
|
|
return False
|
|
|
|
def findDrawableByLayerId(self, id_: int) -> Any:
|
|
"""按图层 ID 查找可绘制对象"""
|
|
if id_ in self._id_map:
|
|
idx = self._id_map[id_]
|
|
if 0 <= idx < len(self._layers):
|
|
return self._layers[idx]
|
|
return None
|
|
|
|
def getLayerCount(self) -> int:
|
|
"""获取图层数量"""
|
|
return len(self._layers)
|
|
|
|
def getNumberOfLayers(self) -> int:
|
|
"""获取图层数量"""
|
|
return len(self._layers)
|
|
|
|
def getId(self, index: int) -> int:
|
|
"""获取图层 ID"""
|
|
for id_, idx in self._id_map.items():
|
|
if idx == index:
|
|
return id_
|
|
return 0
|
|
|
|
def setPadding(self, left: int, top: int, right: int, bottom: int) -> None:
|
|
"""设置内边距"""
|
|
self._padding = (left, top, right, bottom)
|
|
|
|
def setLayerGravity(self, index: int, gravity: int) -> None:
|
|
"""设置图层重力"""
|
|
pass
|
|
|
|
def setLayerWidth(self, index: int, width: int) -> None:
|
|
"""设置图层宽度"""
|
|
pass
|
|
|
|
def setLayerHeight(self, index: int, height: int) -> None:
|
|
"""设置图层高度"""
|
|
pass
|
|
|
|
def setLayerInsetLeft(self, index: int, left: int) -> None:
|
|
if index in self._layer_insets:
|
|
l, t, r, b = self._layer_insets[index]
|
|
self._layer_insets[index] = (left, t, r, b)
|
|
else:
|
|
self._layer_insets[index] = (left, 0, 0, 0)
|
|
|
|
def setLayerInsetRight(self, index: int, right: int) -> None:
|
|
if index in self._layer_insets:
|
|
l, t, r, b = self._layer_insets[index]
|
|
self._layer_insets[index] = (l, t, right, b)
|
|
else:
|
|
self._layer_insets[index] = (0, 0, right, 0)
|
|
|
|
def setLayerInsetTop(self, index: int, top: int) -> None:
|
|
if index in self._layer_insets:
|
|
l, t, r, b = self._layer_insets[index]
|
|
self._layer_insets[index] = (l, top, r, b)
|
|
else:
|
|
self._layer_insets[index] = (0, top, 0, 0)
|
|
|
|
def setLayerInsetBottom(self, index: int, bottom: int) -> None:
|
|
if index in self._layer_insets:
|
|
l, t, r, b = self._layer_insets[index]
|
|
self._layer_insets[index] = (l, t, r, bottom)
|
|
else:
|
|
self._layer_insets[index] = (0, 0, 0, bottom)
|
|
|
|
def setLayerInsetStart(self, index: int, start: int) -> None:
|
|
self.setLayerInsetLeft(index, start)
|
|
|
|
def setLayerInsetEnd(self, index: int, end: int) -> None:
|
|
self.setLayerInsetRight(index, end)
|
|
|
|
def mutate(self) -> "LayerDrawable":
|
|
"""变异"""
|
|
return self
|
|
|
|
|
|
class LevelListDrawable(StateListDrawable):
|
|
"""LevelListDrawable — 级别列表可绘制对象"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# ScaleDrawable / ClipDrawable / RotateDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class ScaleDrawable(ShapeDrawable):
|
|
"""ScaleDrawable — 缩放可绘制对象"""
|
|
|
|
def __init__(self, drawable: Any = None, gravity: int = 0,
|
|
scale_width: float = 1.0, scale_height: float = 1.0):
|
|
super().__init__()
|
|
self._drawable = drawable
|
|
self._gravity = gravity
|
|
self._scale_width = scale_width
|
|
self._scale_height = scale_height
|
|
self._level = 0
|
|
|
|
def setScaleWidth(self, scale_width: float) -> None:
|
|
self._scale_width = scale_width
|
|
|
|
def setScaleHeight(self, scale_height: float) -> None:
|
|
self._scale_height = scale_height
|
|
|
|
def getScale(self) -> Tuple[float, float]:
|
|
return (self._scale_width, self._scale_height)
|
|
|
|
def getLevel(self) -> int:
|
|
return self._level
|
|
|
|
|
|
class ClipDrawable(ShapeDrawable):
|
|
"""ClipDrawable — 裁剪可绘制对象"""
|
|
|
|
HORIZONTAL = 1
|
|
VERTICAL = 2
|
|
|
|
def __init__(self, drawable: Any = None, gravity: int = 0, orientation: int = HORIZONTAL):
|
|
super().__init__()
|
|
self._drawable = drawable
|
|
self._gravity = gravity
|
|
self._orientation = orientation
|
|
|
|
|
|
class RotateDrawable(ShapeDrawable):
|
|
"""RotateDrawable — 旋转可绘制对象"""
|
|
|
|
def __init__(self, drawable: Any = None, gravity: int = 0):
|
|
super().__init__()
|
|
self._drawable = drawable
|
|
self._gravity = gravity
|
|
self._rotation = 0.0
|
|
self._pivot_x = 0.5
|
|
self._pivot_y = 0.5
|
|
|
|
def setRotation(self, rotation: float) -> None:
|
|
self._rotation = rotation
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# TransitionDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class TransitionDrawable(LayerDrawable):
|
|
"""TransitionDrawable — 过渡可绘制对象"""
|
|
|
|
def __init__(self, layers: Optional[List[Any]] = None):
|
|
super().__init__(layers)
|
|
self._cross_fade_enabled = False
|
|
|
|
def startTransition(self, duration_ms: int) -> None:
|
|
"""开始过渡"""
|
|
pass
|
|
|
|
def resetTransition(self) -> None:
|
|
"""重置过渡"""
|
|
pass
|
|
|
|
def reverseTransition(self, duration_ms: int) -> None:
|
|
"""反向过渡"""
|
|
pass
|
|
|
|
def crossFadeEnabled(self) -> bool:
|
|
"""检查是否启用交叉淡入"""
|
|
return self._cross_fade_enabled
|
|
|
|
def setCrossFadeEnabled(self, enabled: bool) -> None:
|
|
"""设置交叉淡入"""
|
|
self._cross_fade_enabled = enabled
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# AnimatedStateListDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class AnimatedStateListDrawable(StateListDrawable):
|
|
"""AnimatedStateListDrawable — 动画状态列表可绘制对象"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._transitions: Dict[Tuple[int, int], Any] = {}
|
|
|
|
def addState(self, state_set: List[int], drawable: Any, state_id: int) -> None:
|
|
"""添加状态"""
|
|
self._states.append((state_set, drawable))
|
|
|
|
def addTransition(self, from_id: int, to_id: int, transition: Any) -> None:
|
|
"""添加过渡"""
|
|
self._transitions[(from_id, to_id)] = transition
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# AnimatedImageDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class AnimatedImageDrawable(ShapeDrawable):
|
|
"""AnimatedImageDrawable — 动画图像可绘制对象"""
|
|
|
|
LOOP_FINITE = 0
|
|
LOOP_INFINITE = -1
|
|
INFINITE = -1
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._running = False
|
|
self._repeat_count = 0
|
|
self._loop_behavior = AnimatedImageDrawable.LOOP_FINITE
|
|
|
|
def start(self) -> None:
|
|
"""开始动画"""
|
|
self._running = True
|
|
|
|
def stop(self) -> None:
|
|
"""停止动画"""
|
|
self._running = False
|
|
|
|
def isRunning(self) -> bool:
|
|
"""检查是否正在运行"""
|
|
return self._running
|
|
|
|
def setRepeatCount(self, count: int) -> None:
|
|
"""设置重复次数"""
|
|
self._repeat_count = count
|
|
|
|
def getRepeatCount(self) -> int:
|
|
"""获取重复次数"""
|
|
return self._repeat_count
|
|
|
|
def setLoopBehavior(self, behavior: int) -> None:
|
|
"""设置循环行为"""
|
|
self._loop_behavior = behavior
|
|
|
|
def getLoopBehavior(self) -> int:
|
|
"""获取循环行为"""
|
|
return self._loop_behavior
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# AnimatedVectorDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class AnimatedVectorDrawable(ShapeDrawable):
|
|
"""AnimatedVectorDrawable — 动画矢量可绘制对象"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._running = False
|
|
self._alpha = 255
|
|
self._hotspot = (0, 0)
|
|
self._hotspot_bounds = (0, 0, 0, 0)
|
|
|
|
def start(self) -> None:
|
|
"""开始动画"""
|
|
self._running = True
|
|
|
|
def stop(self) -> None:
|
|
"""停止动画"""
|
|
self._running = False
|
|
|
|
def reset(self) -> None:
|
|
"""重置动画"""
|
|
self._running = False
|
|
|
|
def isRunning(self) -> bool:
|
|
"""检查是否正在运行"""
|
|
return self._running
|
|
|
|
def setVisible(self, visible: bool, restart: bool) -> bool:
|
|
"""设置可见性"""
|
|
return True
|
|
|
|
def setAlpha(self, alpha: int) -> None:
|
|
"""设置透明度"""
|
|
self._alpha = alpha
|
|
|
|
def getAlpha(self) -> int:
|
|
"""获取透明度"""
|
|
return self._alpha
|
|
|
|
def setHotspot(self, x: float, y: float) -> None:
|
|
"""设置热点"""
|
|
self._hotspot = (x, y)
|
|
|
|
def setHotspotBounds(self, left: int, top: int, right: int, bottom: int) -> None:
|
|
"""设置热点边界"""
|
|
self._hotspot_bounds = (left, top, right, bottom)
|
|
|
|
def getIntrinsicWidth(self) -> int:
|
|
return 48
|
|
|
|
def getIntrinsicHeight(self) -> int:
|
|
return 48
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# RippleDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class RippleDrawable(ShapeDrawable):
|
|
"""RippleDrawable — 水波纹可绘制对象"""
|
|
|
|
RIPPLE_ENTERING = 0
|
|
RIPPLE_EXITING = 1
|
|
|
|
def __init__(self, color: int = 0, content: Any = None, mask: Any = None):
|
|
super().__init__()
|
|
self._radius = 0
|
|
self._color = color
|
|
self._effect_color = color
|
|
self._content = content
|
|
self._mask = mask
|
|
self._ripple_state = RippleDrawable.RIPPLE_ENTERING
|
|
|
|
def setRadius(self, radius: int) -> None:
|
|
"""设置半径"""
|
|
self._radius = radius
|
|
|
|
def getRadius(self) -> int:
|
|
"""获取半径"""
|
|
return self._radius
|
|
|
|
def setColor(self, color: int) -> None:
|
|
"""设置颜色"""
|
|
self._color = color
|
|
|
|
def getColor(self) -> int:
|
|
"""获取颜色"""
|
|
return self._color
|
|
|
|
def setEffectColor(self, color: int) -> None:
|
|
"""设置效果颜色"""
|
|
self._effect_color = color
|
|
|
|
def getEffectColor(self) -> int:
|
|
"""获取效果颜色"""
|
|
return self._effect_color
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# AnimatedRotateDrawable / InsetDrawable / NinePatchDrawable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class AnimatedRotateDrawable(ShapeDrawable):
|
|
"""AnimatedRotateDrawable — 动画旋转可绘制对象"""
|
|
|
|
def __init__(self, drawable: Any = None, gravity: int = 0):
|
|
super().__init__()
|
|
self._drawable = drawable
|
|
self._gravity = gravity
|
|
self._running = False
|
|
|
|
def start(self) -> None:
|
|
self._running = True
|
|
|
|
def stop(self) -> None:
|
|
self._running = False
|
|
|
|
|
|
class InsetDrawable(ShapeDrawable):
|
|
"""InsetDrawable — 嵌入可绘制对象"""
|
|
|
|
def __init__(self, drawable: Any = None, inset: int = 0):
|
|
super().__init__()
|
|
self._drawable = drawable
|
|
self._inset = inset
|
|
self._outset = inset
|
|
|
|
def getInset(self) -> int:
|
|
"""获取嵌入"""
|
|
return self._inset
|
|
|
|
def getOutset(self) -> int:
|
|
"""获取外延"""
|
|
return self._outset
|
|
|
|
|
|
class NinePatchDrawable(ShapeDrawable):
|
|
"""NinePatchDrawable — 九宫格可绘制对象"""
|
|
|
|
def __init__(self, nine_patch: Any = None):
|
|
super().__init__()
|
|
self._nine_patch = nine_patch
|
|
|
|
def getIntrinsicWidth(self) -> int:
|
|
return 0
|
|
|
|
def getIntrinsicHeight(self) -> int:
|
|
return 0 |