arkivy 1.0__tar.gz

arkivy-1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: arkivy
+Version: 1.0
+Summary: Help library with kivy in Arabic language formatting
+Author: ALI KAZM
+
+
+
+install library
+
+``pip instal arkivy``
+
+

arkivy-1.0/arkivy/__init__.py

@@ -0,0 +1,3 @@
+from .button import ArButton
+from .label import ArLabel
+from .textinput import ArTextInput,ArTextInputBase

arkivy-1.0/arkivy/button.py

@@ -0,0 +1,23 @@
+
+from .utils import ar
+from .label import ArLabel
+from kivy.uix.button import Button
+from .ripple import RectangularRippleBehavior
+
+__all__=('ArButton',)
+
+
+class ArButton(ArLabel,RectangularRippleBehavior,Button):
+    pass
+
+
+
+
+
+
+
+
+
+
+
+

arkivy-1.0/arkivy/label.py

@@ -0,0 +1,23 @@
+from kivy.properties import StringProperty
+from kivy.uix.label import Label
+from .utils import ar
+
+__all__=('ArLabel',)
+
+class ArLabel(Label):
+    text=StringProperty()
+    def __init__(self,*args,**kwargs):
+        super().__init__(*args,**kwargs)
+        #self.font_name=
+        self._label.text=ar(self.text)
+    def _trigger_texture_update(self, name=None, source=None, value=None):
+        if source:
+            if name == 'text':
+                self._label.text = ar(value)
+                self._trigger_texture()
+            else:
+                return super()._trigger_texture_update(name,source,value)
+
+
+
+

arkivy-1.0/arkivy/ripple.py

@@ -0,0 +1,285 @@
+
+
+__all__ = (
+    "CommonRipple",
+    "RectangularRippleBehavior",
+    "CircularRippleBehavior",
+)
+
+from typing import NoReturn
+
+from kivy.animation import Animation
+from kivy.graphics import (
+    Color,
+    Ellipse,
+    StencilPop,
+    StencilPush,
+    StencilUnUse,
+    StencilUse,
+)
+from kivy.graphics.vertex_instructions import RoundedRectangle
+from kivy.properties import (
+    BooleanProperty,
+    ColorProperty,
+    ListProperty,
+    NumericProperty,
+    StringProperty,
+)
+from kivy.uix.behaviors import ToggleButtonBehavior
+
+
+class CommonRipple:
+
+
+    ripple_rad_default = NumericProperty(1)
+
+
+    ripple_color = ColorProperty(None)
+
+    ripple_alpha = NumericProperty(0.5)
+
+
+    ripple_scale = NumericProperty(None)
+
+
+    ripple_duration_in_fast = NumericProperty(0.3)
+
+
+    ripple_duration_in_slow = NumericProperty(2)
+
+
+    ripple_duration_out = NumericProperty(0.3)
+
+
+    ripple_canvas_after = BooleanProperty(True)
+
+
+    ripple_func_in = StringProperty("out_quad")
+
+    ripple_func_out = StringProperty("out_quad")
+
+
+    _ripple_rad = NumericProperty()
+    _doing_ripple = BooleanProperty(False)
+    _finishing_ripple = BooleanProperty(False)
+    _fading_out = BooleanProperty(False)
+    _no_ripple_effect = BooleanProperty(False)
+    _round_rad = ListProperty([0, 0, 0, 0])
+
+    def lay_canvas_instructions(self) -> NoReturn:
+        raise NotImplementedError
+
+    def start_ripple(self) -> None:
+        if not self._doing_ripple:
+            self._doing_ripple = True
+            anim = Animation(
+                _ripple_rad=self.finish_rad,
+                t="linear",
+                duration=self.ripple_duration_in_slow,
+            )
+            anim.bind(on_complete=self.fade_out)
+            anim.start(self)
+
+    def finish_ripple(self) -> None:
+        if self._doing_ripple and not self._finishing_ripple:
+            self._finishing_ripple = True
+            self._doing_ripple = False
+            Animation.cancel_all(self, "_ripple_rad")
+            anim = Animation(
+                _ripple_rad=self.finish_rad,
+                t=self.ripple_func_in,
+                duration=self.ripple_duration_in_fast,
+            )
+            anim.bind(on_complete=self.fade_out)
+            anim.start(self)
+
+    def fade_out(self, *args) -> None:
+        rc = self.ripple_color
+        if not self._fading_out:
+            self._fading_out = True
+            Animation.cancel_all(self, "ripple_color")
+            anim = Animation(
+                ripple_color=[rc[0], rc[1], rc[2], 0.0],
+                t=self.ripple_func_out,
+                duration=self.ripple_duration_out,
+            )
+            anim.bind(on_complete=self.anim_complete)
+            anim.start(self)
+
+    def anim_complete(self, *args) -> None:
+        self._doing_ripple = False
+        self._finishing_ripple = False
+        self._fading_out = False
+
+        if not self.ripple_canvas_after:
+            canvas = self.canvas.before
+        else:
+            canvas = self.canvas.after
+
+        canvas.remove_group("circular_ripple_behavior")
+        canvas.remove_group("rectangular_ripple_behavior")
+
+    def on_touch_down(self, touch):
+
+        super().on_touch_down(touch)
+        if touch.is_mouse_scrolling:
+            return False
+        if not self.collide_point(touch.x, touch.y):
+            return False
+        if not self.disabled:
+            self.call_ripple_animation_methods(touch)
+
+            if isinstance(self, ToggleButtonBehavior):
+                return super().on_touch_down(touch)
+            else:
+                return True
+
+    def call_ripple_animation_methods(self, touch) -> None:
+        if self._doing_ripple:
+            Animation.cancel_all(
+                self, "_ripple_rad", "ripple_color", "rect_color"
+            )
+            self.anim_complete()
+        self._ripple_rad = self.ripple_rad_default
+        self.ripple_pos = (touch.x, touch.y)
+
+        if self.ripple_color:
+            pass
+        elif hasattr(self, "theme_cls"):
+            self.ripple_color = self.theme_cls.ripple_color
+        else:
+            # If no theme, set Gray 300.
+            self.ripple_color = [
+                0.8784313725490196,
+                0.8784313725490196,
+                0.8784313725490196,
+                self.ripple_alpha,
+            ]
+        self.ripple_color[3] = self.ripple_alpha
+        self.lay_canvas_instructions()
+        self.finish_rad = max(self.width, self.height) * self.ripple_scale
+        self.start_ripple()
+
+    def on_touch_move(self, touch, *args):
+        if not self.collide_point(touch.x, touch.y):
+            if not self._finishing_ripple and self._doing_ripple:
+                self.finish_ripple()
+        return super().on_touch_move(touch, *args)
+
+    def on_touch_up(self, touch):
+        if self.collide_point(touch.x, touch.y) and self._doing_ripple:
+            self.finish_ripple()
+        return super().on_touch_up(touch)
+
+    def _set_ellipse(self, instance, value):
+        self.ellipse.size = (self._ripple_rad, self._ripple_rad)
+
+    # Adjust ellipse pos here
+
+    def _set_color(self, instance, value):
+        self.col_instruction.a = value[3]
+
+
+class RectangularRippleBehavior(CommonRipple):
+
+
+    ripple_scale = NumericProperty(2.75)
+
+    def lay_canvas_instructions(self) -> None:
+        if self._no_ripple_effect:
+            return
+
+        with self.canvas.after if self.ripple_canvas_after else self.canvas.before:
+            if hasattr(self, "radius"):
+                if isinstance(self.radius, (float, int)):
+                    self.radius = [
+                        self.radius,
+                    ]
+                self._round_rad = self.radius
+            StencilPush(group="rectangular_ripple_behavior")
+            RoundedRectangle(
+                pos=self.pos,
+                size=self.size,
+                radius=self._round_rad,
+                group="rectangular_ripple_behavior",
+            )
+            StencilUse(group="rectangular_ripple_behavior")
+            self.col_instruction = Color(
+                rgba=self.ripple_color, group="rectangular_ripple_behavior"
+            )
+            self.ellipse = Ellipse(
+                size=(self._ripple_rad, self._ripple_rad),
+                pos=(
+                    self.ripple_pos[0] - self._ripple_rad / 2.0,
+                    self.ripple_pos[1] - self._ripple_rad / 2.0,
+                ),
+                group="rectangular_ripple_behavior",
+            )
+            StencilUnUse(group="rectangular_ripple_behavior")
+            RoundedRectangle(
+                pos=self.pos,
+                size=self.size,
+                radius=self._round_rad,
+                group="rectangular_ripple_behavior",
+            )
+            StencilPop(group="rectangular_ripple_behavior")
+        self.bind(ripple_color=self._set_color, _ripple_rad=self._set_ellipse)
+
+    def _set_ellipse(self, instance, value):
+        super()._set_ellipse(instance, value)
+        self.ellipse.pos = (
+            self.ripple_pos[0] - self._ripple_rad / 2.0,
+            self.ripple_pos[1] - self._ripple_rad / 2.0,
+        )
+
+
+class CircularRippleBehavior(CommonRipple):
+
+
+    ripple_scale = NumericProperty(1)
+
+
+    def lay_canvas_instructions(self) -> None:
+        if self._no_ripple_effect:
+            return
+
+        with self.canvas.after if self.ripple_canvas_after else self.canvas.before:
+            StencilPush(group="circular_ripple_behavior")
+            self.stencil = Ellipse(
+                size=(
+                    self.width * self.ripple_scale,
+                    self.height * self.ripple_scale,
+                ),
+                pos=(
+                    self.center_x - (self.width * self.ripple_scale) / 2,
+                    self.center_y - (self.height * self.ripple_scale) / 2,
+                ),
+                group="circular_ripple_behavior",
+            )
+            StencilUse(group="circular_ripple_behavior")
+            self.col_instruction = Color(rgba=self.ripple_color)
+            self.ellipse = Ellipse(
+                size=(self._ripple_rad, self._ripple_rad),
+                pos=(
+                    self.center_x - self._ripple_rad / 2.0,
+                    self.center_y - self._ripple_rad / 2.0,
+                ),
+                group="circular_ripple_behavior",
+            )
+            StencilUnUse(group="circular_ripple_behavior")
+            Ellipse(
+                pos=self.pos, size=self.size, group="circular_ripple_behavior"
+            )
+            StencilPop(group="circular_ripple_behavior")
+            self.bind(
+                ripple_color=self._set_color, _ripple_rad=self._set_ellipse
+            )
+
+    def _set_ellipse(self, instance, value):
+        super()._set_ellipse(instance, value)
+        if self.ellipse.size[0] > self.width * 0.6 and not self._fading_out:
+            self.fade_out()
+        self.ellipse.pos = (
+            self.center_x - self._ripple_rad / 2.0,
+            self.center_y - self._ripple_rad / 2.0,
+        )

arkivy-1.0/arkivy/textinput.py

@@ -0,0 +1,34 @@
+from kivy.uix.accordion import StringProperty
+from kivy.uix.textinput import TextInput
+from .utils import ar
+
+__all__=('ArTextInput','ArTextInputBase',)
+
+class ArTextInput(TextInput):
+    t=StringProperty()
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.base_direction='rtl'
+    def insert_text(self, substring, from_undo=False):
+        self.t+=substring
+        self.text=ar(self.t)
+    def do_backspace(self, from_undo=False, mode='bkspc'):
+        self.t=self.t[:-1]
+        self.text=ar(self.t)
+
+
+class ArTextInputBase:
+    t=StringProperty()
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.base_direction='rtl'
+    def insert_text(self, substring, from_undo=False):
+        self.t+=substring
+        self.text=ar(self.t)
+    def do_backspace(self, from_undo=False, mode='bkspc'):
+        self.t=self.t[:-1]
+        self.text=ar(self.t)
+
+
+
+

arkivy-1.0/arkivy/utils.py

@@ -0,0 +1,18 @@
+from arabic_reshaper import reshape
+from bidi.algorithm import get_display
+
+
+def ar(text):
+    return get_display(reshape(text))
+
+
+
+
+
+
+
+
+
+
+
+

arkivy-1.0/arkivy.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: arkivy
+Version: 1.0
+Summary: Help library with kivy in Arabic language formatting
+Author: ALI KAZM
+
+
+
+install library
+
+``pip instal arkivy``
+
+

arkivy-1.0/arkivy.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+setup.py
+arkivy/__init__.py
+arkivy/button.py
+arkivy/label.py
+arkivy/ripple.py
+arkivy/textinput.py
+arkivy/utils.py
+arkivy.egg-info/PKG-INFO
+arkivy.egg-info/SOURCES.txt
+arkivy.egg-info/dependency_links.txt
+arkivy.egg-info/requires.txt
+arkivy.egg-info/top_level.txt

arkivy-1.0/arkivy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

arkivy-1.0/arkivy.egg-info/requires.txt

@@ -0,0 +1,3 @@
+arabic_reshaper
+kivy
+python_bidi

arkivy-1.0/arkivy.egg-info/top_level.txt

@@ -0,0 +1 @@
+arkivy

arkivy-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

arkivy-1.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup,find_packages
+
+d='''
+
+install library
+
+``pip instal arkivy``
+
+
+'''
+
+
+
+
+
+
+setup(
+	version='1.0',
+	name='arkivy',
+	author='ALI KAZM',
+	description='Help library with kivy in Arabic language formatting',
+	packages=find_packages(),
+	long_description=d,
+	install_requires=['arabic_reshaper','python_bidi','kivy'],
+	
+
+)
+
+
+