dhxpyt.form

 14class Form:
 15    def __init__(self, config: FormConfig = None, widget_parent: Any = None):
 16        """Initializes the Form instance."""
 17        if config is None:
 18            config = FormConfig()
 19        config_dict = config.to_dict()
 20        self.form = js.dhx.Form.new(widget_parent, js.JSON.parse(json.dumps(config_dict)))
 21
 22    """ Form API Functions """
 23
 24    def blur(self, name: str = None) -> None:
 25        """Removes focus from a control of the Form."""
 26        self.form.blur(name)
 27
 28    def clear(self, method: str = None) -> None:
 29        """Clears the form."""
 30        self.form.clear(method)
 31
 32    def destructor(self) -> None:
 33        """Removes the Form instance and releases occupied resources."""
 34        self.form.destructor()
 35
 36    def disable(self) -> None:
 37        """Disables the Form."""
 38        self.form.disable()
 39
 40    def enable(self) -> None:
 41        """Enables the Form."""
 42        self.form.enable()
 43
 44    def for_each(self, callback: Callable[[Any, int, List[Any]], Any]) -> None:
 45        """Iterates over all controls of the Form."""
 46        proxy_callback = create_proxy(callback)
 47        self.form.forEach(proxy_callback)
 48
 49    def get_item(self, name: str) -> Any:
 50        """Gives access to the object of a Form control."""
 51        return self.form.getItem(name)
 52
 53    def get_properties(self, name: str = None) -> Union[Dict[str, Any], Dict[str, Dict[str, Any]]]:
 54        """Returns objects with available configuration attributes of Form controls."""
 55        return self.form.getProperties(name)
 56
 57    def get_value(self, as_form_data: bool = False) -> Dict[str, Any]:
 58        """Gets current values/states of controls."""
 59        return self.form.getValue(as_form_data)
 60
 61    def hide(self) -> None:
 62        """Hides the Form."""
 63        self.form.hide()
 64
 65    def is_disabled(self, name: str = None) -> bool:
 66        """Checks whether the Form or a control is disabled."""
 67        return self.form.isDisabled(name)
 68
 69    def is_visible(self, name: str = None) -> bool:
 70        """Checks whether the Form or a control is visible."""
 71        return self.form.isVisible(name)
 72
 73    def paint(self) -> None:
 74        """Repaints the Form on the page."""
 75        self.form.paint()
 76
 77    def send(self, url: str, method: str = "POST", as_form_data: bool = False) -> Any:
 78        """Sends the Form to the server."""
 79        return self.form.send(url, method, as_form_data)
 80
 81    def set_focus(self, name: str) -> None:
 82        """Sets focus to a Form control by its name or id."""
 83        self.form.setFocus(name)
 84
 85    def set_properties(self, arg: Union[str, Dict[str, Dict[str, Any]]], properties: Dict[str, Any] = None) -> None:
 86        """Allows changing available configuration attributes of Form controls dynamically."""
 87        if isinstance(arg, str):
 88            self.form.setProperties(arg, js.JSON.parse(json.dumps(properties)))
 89        elif isinstance(arg, dict):
 90            props = {k: js.JSON.parse(json.dumps(v)) for k, v in arg.items()}
 91            self.form.setProperties(props)
 92        else:
 93            raise TypeError("Argument must be a string or a dictionary")
 94
 95    def set_value(self, obj: Dict[str, Any]) -> None:
 96        """Sets values/states for controls."""
 97        self.form.setValue(js.JSON.parse(json.dumps(obj)))
 98
 99    def show(self) -> None:
100        """Shows the Form on the page."""
101        self.form.show()
102
103    def validate(self, silent: bool = False) -> bool:
104        """Validates form fields."""
105        return self.form.validate(silent)
106
107    """ Form Events """
108
109    def add_event_handler(self, event_name: str, handler: Callable) -> None:
110        """Helper to add event handlers dynamically."""
111        event_proxy = create_proxy(handler)
112        self.form.events.on(event_name, event_proxy)
113
114    def on_after_change_properties(self, handler: Callable[[str, Dict[str, Any]], None]) -> None:
115        """Fires after configuration attributes of a Form control have been changed dynamically."""
116        self.add_event_handler('afterChangeProperties', handler)
117
118    def on_after_hide(self, handler: Callable[[str, Any, str], None]) -> None:
119        """Fires after a Form control or its element is hidden."""
120        self.add_event_handler('afterHide', handler)
121
122    def on_after_send(self, handler: Callable[[], None]) -> None:
123        """Fires after a form is sent to the server."""
124        self.add_event_handler('afterSend', handler)
125
126    def on_after_show(self, handler: Callable[[str, Any, str], None]) -> None:
127        """Fires after a Form control or its element is shown."""
128        self.add_event_handler('afterShow', handler)
129
130    def on_after_validate(self, handler: Callable[[str, Any, bool], None]) -> None:
131        """Fires after validation of form fields is finished."""
132        self.add_event_handler('afterValidate', handler)
133
134    def on_before_change(self, handler: Callable[[str, Any], Union[bool, None]]) -> None:
135        """Fires before changing the value of a control."""
136        def event_handler(name, value):
137            result = handler(name, value)
138            if result is False:
139                return js.Boolean(False)
140        self.form.events.on('beforeChange', create_proxy(event_handler))
141
142    def on_before_change_properties(self, handler: Callable[[str, Dict[str, Any]], Union[bool, None]]) -> None:
143        """Fires before configuration attributes of a Form control are changed dynamically."""
144        def event_handler(name, properties):
145            result = handler(name, properties)
146            if result is False:
147                return js.Boolean(False)
148        self.form.events.on('beforeChangeProperties', create_proxy(event_handler))
149
150    def on_before_hide(self, handler: Callable[[Union[str, int], Any, str], Union[bool, None]]) -> None:
151        """Fires before a Form control or its element is hidden."""
152        def event_handler(name, value=None, id=None):
153            result = handler(name, value, id)
154            if result is False:
155                return js.Boolean(False)
156        self.form.events.on('beforeHide', create_proxy(event_handler))
157
158    def on_before_send(self, handler: Callable[[], Union[bool, None]]) -> None:
159        """Fires before a form is sent to the server."""
160        def event_handler():
161            result = handler()
162            if result is False:
163                return js.Boolean(False)
164        self.form.events.on('beforeSend', create_proxy(event_handler))
165
166    def on_before_show(self, handler: Callable[[str, Any, str], Union[bool, None]]) -> None:
167        """Fires before a Form control or its element is shown."""
168        def event_handler(name, value=None, id=None):
169            result = handler(name, value, id)
170            if result is False:
171                return js.Boolean(False)
172        self.form.events.on('beforeShow', create_proxy(event_handler))
173
174    def on_before_validate(self, handler: Callable[[str, Any], Union[bool, None]]) -> None:
175        """Fires before validation of form fields has started."""
176        def event_handler(name, value):
177            result = handler(name, value)
178            if result is False:
179                return js.Boolean(False)
180        self.form.events.on('beforeValidate', create_proxy(event_handler))
181
182    def on_blur(self, handler: Callable[[str, Any, str], None]) -> None:
183        """Fires when a control of Form has lost focus."""
184        self.add_event_handler('blur', handler)
185
186    def on_change(self, handler: Callable[[str, Any], None]) -> None:
187        """Fires on changing the value of a control."""
188        self.add_event_handler('change', handler)
189
190    def on_click(self, handler: Callable[[str, Any], Any]) -> None:
191        """Fires after a click on a button in a form."""
192        self.add_event_handler('click', handler)
193
194    def on_focus(self, handler: Callable[[str, Any, str], None]) -> None:
195        """Fires when a control of Form has received focus."""
196        self.add_event_handler('focus', handler)
197
198    def on_keydown(self, handler: Callable[[Any, str, str], None]) -> None:
199        """Fires when any key is pressed."""
200        self.add_event_handler('keydown', handler)
201
202    """ Form Properties """
203
204    @property
205    def align(self) -> str:
206        """Gets or sets the alignment of controls inside the control group."""
207        return self.form.config.align
208
209    @align.setter
210    def align(self, value: str) -> None:
211        self.form.config.align = value
212
213    @property
214    def cols(self) -> List[Dict[str, Any]]:
215        """Gets or sets the columns of controls inside the control group."""
216        return self.form.config.cols
217
218    @cols.setter
219    def cols(self, value: List[Dict[str, Any]]) -> None:
220        self.form.config.cols = value
221
222    @property
223    def css(self) -> str:
224        """Gets or sets the CSS classes applied to the control group."""
225        return self.form.config.css
226
227    @css.setter
228    def css(self, value: str) -> None:
229        self.form.config.css = value
230
231    @property
232    def disabled(self) -> bool:
233        """Gets or sets whether the Form is disabled."""
234        return self.form.config.disabled
235
236    @disabled.setter
237    def disabled(self, value: bool) -> None:
238        self.form.config.disabled = value
239
240    @property
241    def height(self) -> Union[str, int]:
242        """Gets or sets the height of the control group."""
243        return self.form.config.height
244
245    @height.setter
246    def height(self, value: Union[str, int, str]) -> None:
247        self.form.config.height = value
248
249    @property
250    def hidden(self) -> bool:
251        """Gets or sets whether the Form is hidden."""
252        return self.form.config.hidden
253
254    @hidden.setter
255    def hidden(self, value: bool) -> None:
256        self.form.config.hidden = value
257
258    @property
259    def padding(self) -> Union[str, int]:
260        """Gets or sets the padding for content inside the control group."""
261        return self.form.config.padding
262
263    @padding.setter
264    def padding(self, value: Union[str, int]) -> None:
265        self.form.config.padding = value
266
267    @property
268    def rows(self) -> List[Dict[str, Any]]:
269        """Gets or sets the rows of controls inside the control group."""
270        return self.form.config.rows
271
272    @rows.setter
273    def rows(self, value: List[Dict[str, Any]]) -> None:
274        self.form.config.rows = value
275
276    @property
277    def title(self) -> str:
278        """Gets or sets the title of the control group."""
279        return self.form.config.title
280
281    @title.setter
282    def title(self, value: str) -> None:
283        self.form.config.title = value
284
285    @property
286    def width(self) -> Union[str, int]:
287        """Gets or sets the width of the control group."""
288        return self.form.config.width
289
290    @width.setter
291    def width(self, value: Union[str, int, str]) -> None:
292        self.form.config.width = value

15class FormConfig:
16    """
17    Configuration class for Form.
18    """
19    def __init__(self,
20                 align: str = "start",
21                 cols: List[Dict[str, Any]] = None,
22                 css: str = None,
23                 disabled: bool = False,
24                 height: Union[str, int] = "content",
25                 hidden: bool = False,
26                 padding: Union[str, int] = None,
27                 rows: List[Dict[str, Any]] = None,
28                 title: str = None,
29                 width: Union[str, int] = "content"):
30        """
31        :param align: (Optional) Sets the alignment of controls inside the control group.
32        :param cols: (Optional) Arranges controls inside the control group horizontally.
33        :param css: (Optional) The name of a CSS class(es) applied to the control group.
34        :param disabled: (Optional) Makes a form disabled.
35        :param height: (Optional) Sets the height of the control group.
36        :param hidden: (Optional) Defines whether a form is hidden.
37        :param padding: (Optional) Sets padding for content inside the control group.
38        :param rows: (Optional) Arranges controls inside the control group vertically.
39        :param title: (Optional) Specifies the title of the control group.
40        :param width: (Optional) Sets the width of the control group.
41        """
42        self.align = align
43        self.cols = cols if cols else []
44        self.css = css
45        self.disabled = disabled
46        self.height = height
47        self.hidden = hidden
48        self.padding = padding
49        self.rows = rows if rows else []
50        self.title = title
51        self.width = width
52
53    def to_dict(self) -> Dict[str, Any]:
54        """
55        Converts the FormConfig into a dictionary format that can be
56        passed into the form constructor.
57        """
58        config_dict = {
59            'align': self.align,
60            'cols': self.cols,
61            'css': self.css,
62            'disabled': self.disabled,
63            'height': self.height,
64            'hidden': self.hidden,
65            'padding': self.padding,
66            'rows': self.rows,
67            'title': self.title,
68            'width': self.width
69        }
70
71        if 'cols' in config_dict:
72            config_dict['cols'] = [process_item(col) for col in config_dict['cols']]
73        if 'rows' in config_dict:
74            config_dict['rows'] = [process_item(row) for row in config_dict['rows']]
75
76            
77        # Remove None values
78        return {k: v for k, v in config_dict.items() if v is not None}

 14class Avatar:
 15    def __init__(self, config: AvatarConfig = None, widget_parent: Any = None):
 16        """Initializes the Avatar control."""
 17        if config is None:
 18            config = AvatarConfig()
 19        config_dict = config.to_dict()
 20        self.avatar = js.dhx.FormControl.new(widget_parent, js.JSON.parse(json.dumps(config_dict)))
 21
 22    """ Avatar API Functions """
 23
 24    def blur(self) -> None:
 25        """Removes focus from the control."""
 26        self.avatar.blur()
 27
 28    def clear(self) -> None:
 29        """Clears the value of the Avatar control."""
 30        self.avatar.clear()
 31
 32    def clear_validate(self) -> None:
 33        """Clears validation of the Avatar control."""
 34        self.avatar.clearValidate()
 35
 36    def destructor(self) -> None:
 37        """Removes the Avatar instance and releases the occupied resources."""
 38        self.avatar.destructor()
 39
 40    def disable(self) -> None:
 41        """Disables the Avatar control."""
 42        self.avatar.disable()
 43
 44    def enable(self) -> None:
 45        """Enables the Avatar control."""
 46        self.avatar.enable()
 47
 48    def focus(self) -> None:
 49        """Sets focus to the control."""
 50        self.avatar.focus()
 51
 52    def get_properties(self) -> Dict[str, Any]:
 53        """Returns an object with the available configuration attributes of the control."""
 54        return self.avatar.getProperties().to_py()
 55
 56    def get_value(self) -> Dict[str, Any]:
 57        """Returns the current value of the Avatar control."""
 58        return self.avatar.getValue().to_py()
 59
 60    def hide(self) -> None:
 61        """Hides the Avatar control."""
 62        self.avatar.hide()
 63
 64    def is_disabled(self) -> bool:
 65        """Checks whether the Avatar control is disabled."""
 66        return self.avatar.isDisabled()
 67
 68    def is_visible(self) -> bool:
 69        """Checks whether the Avatar control is visible on the page."""
 70        return self.avatar.isVisible()
 71
 72    def select_file(self) -> None:
 73        """Opens the dialog for selecting an image."""
 74        self.avatar.selectFile()
 75
 76    def send(self, params: Dict[str, Any] = None) -> None:
 77        """Sends a POST request for a file upload to a server-side URL."""
 78        self.avatar.send(js.JSON.parse(json.dumps(params or {})))
 79
 80    def set_properties(self, properties: Dict[str, Any]) -> None:
 81        """Allows changing available configuration attributes of the control dynamically."""
 82        self.avatar.setProperties(js.JSON.parse(json.dumps(properties)))
 83
 84    def set_value(self, value: Dict[str, Any]) -> None:
 85        """Sets the value for the Avatar control."""
 86        self.avatar.setValue(js.JSON.parse(json.dumps(value)))
 87
 88    def show(self) -> None:
 89        """Shows the Avatar control on the page."""
 90        self.avatar.show()
 91
 92    def validate(self, silent: bool = False, validate_value: Dict[str, Any] = None) -> bool:
 93        """Validates the Avatar control."""
 94        return self.avatar.validate(silent, js.JSON.parse(json.dumps(validate_value or {})))
 95
 96    """ Avatar Events """
 97
 98    def add_event_handler(self, event_name: str, handler: Callable) -> None:
 99        """Helper to add event handlers dynamically."""
100        event_proxy = create_proxy(handler)
101        self.avatar.events.on(event_name, event_proxy)
102
103    def on_after_change_properties(self, handler: Callable[[Dict[str, Any]], None]) -> None:
104        """Fires after configuration attributes have been changed dynamically."""
105        self.add_event_handler('afterChangeProperties', handler)
106
107    def on_after_hide(self, handler: Callable[[Dict[str, Any], bool], None]) -> None:
108        """Fires after the control is hidden."""
109        self.add_event_handler('afterHide', handler)
110
111    def on_after_show(self, handler: Callable[[Dict[str, Any]], None]) -> None:
112        """Fires after the control is shown."""
113        self.add_event_handler('afterShow', handler)
114
115    def on_after_validate(self, handler: Callable[[Dict[str, Any], bool], None]) -> None:
116        """Fires after the control value is validated."""
117        self.add_event_handler('afterValidate', handler)
118
119    def on_before_change(self, handler: Callable[[Dict[str, Any]], Union[bool, None]]) -> None:
120        """Fires before changing the value of the control."""
121        def event_handler(value):
122            result = handler(value.to_py())
123            if result is False:
124                return js.Boolean(False)
125        self.avatar.events.on('beforeChange', create_proxy(event_handler))
126
127    def on_before_change_properties(self, handler: Callable[[Dict[str, Any]], Union[bool, None]]) -> None:
128        """Fires before configuration attributes are changed dynamically."""
129        def event_handler(properties):
130            result = handler(properties.to_py())
131            if result is False:
132                return js.Boolean(False)
133        self.avatar.events.on('beforeChangeProperties', create_proxy(event_handler))
134
135    def on_before_hide(self, handler: Callable[[Dict[str, Any], bool], Union[bool, None]]) -> None:
136        """Fires before the control is hidden."""
137        def event_handler(value, init):
138            result = handler(value.to_py(), init)
139            if result is False:
140                return js.Boolean(False)
141        self.avatar.events.on('beforeHide', create_proxy(event_handler))
142
143    def on_before_show(self, handler: Callable[[Dict[str, Any]], Union[bool, None]]) -> None:
144        """Fires before the control is shown."""
145        def event_handler(value):
146            result = handler(value.to_py())
147            if result is False:
148                return js.Boolean(False)
149        self.avatar.events.on('beforeShow', create_proxy(event_handler))
150
151    def on_before_upload_file(self, handler: Callable[[Dict[str, Any]], Union[bool, None]]) -> None:
152        """Fires before file upload begins."""
153        def event_handler(value):
154            result = handler(value.to_py())
155            if result is False:
156                return js.Boolean(False)
157        self.avatar.events.on('beforeUploadFile', create_proxy(event_handler))
158
159    def on_before_validate(self, handler: Callable[[Dict[str, Any]], Union[bool, None]]) -> None:
160        """Fires before the control value is validated."""
161        def event_handler(value):
162            result = handler(value.to_py())
163            if result is False:
164                return js.Boolean(False)
165        self.avatar.events.on('beforeValidate', create_proxy(event_handler))
166
167    def on_blur(self, handler: Callable[[Dict[str, Any]], None]) -> None:
168        """Fires when the control has lost focus."""
169        self.add_event_handler('blur', handler)
170
171    def on_change(self, handler: Callable[[Dict[str, Any]], None]) -> None:
172        """Fires on changing the value of the control."""
173        self.add_event_handler('change', handler)
174
175    def on_focus(self, handler: Callable[[Dict[str, Any]], None]) -> None:
176        """Fires when the control has received focus."""
177        self.add_event_handler('focus', handler)
178
179    def on_keydown(self, handler: Callable[[Any], None]) -> None:
180        """Fires when any key is pressed and the control is in focus."""
181        self.add_event_handler('keydown', handler)
182
183    def on_upload_begin(self, handler: Callable[[Dict[str, Any]], None]) -> None:
184        """Fires when file upload begins."""
185        self.add_event_handler('uploadBegin', handler)
186
187    def on_upload_complete(self, handler: Callable[[Dict[str, Any]], None]) -> None:
188        """Fires when upload is completed."""
189        self.add_event_handler('uploadComplete', handler)
190
191    def on_upload_fail(self, handler: Callable[[Dict[str, Any]], None]) -> None:
192        """Fires if the file upload failed."""
193        self.add_event_handler('uploadFail', handler)
194
195    def on_upload_file(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
196        """Fires when a file has been uploaded."""
197        self.add_event_handler('uploadFile', handler)
198
199    def on_upload_progress(self, handler: Callable[[int, Dict[str, Any]], None]) -> None:
200        """Fires on each percent of a file uploading."""
201        self.add_event_handler('uploadProgress', handler)