dhxpyt.grid

 14class Grid:
 15    def __init__(self, config: GridConfig = None, widget_parent: str = None):
 16        """
 17        Initializes the Grid widget.
 18
 19        :param config: (Optional) The GridConfig object containing the grid configuration.
 20        :param widget_parent: (Optional) The ID of the HTML element where the grid will be attached.
 21        """
 22        if config is None:
 23            config = GridConfig()
 24        config_dict = config.to_dict()
 25        self.grid = js.dhx.Grid.new(widget_parent, js.JSON.parse(json.dumps(config_dict)))
 26
 27    """ Grid API Functions """
 28
 29    def add_cell_css(self, row_id: Union[str, int], col_id: Union[str, int], css: str) -> None:
 30        """Adds a CSS class to a cell."""
 31        self.grid.addCellCss(row_id, col_id, css)
 32
 33    def add_row_css(self, row_id: Union[str, int], css: str) -> None:
 34        """Adds a CSS class to a row."""
 35        self.grid.addRowCss(row_id, css)
 36
 37    def add_span(self, span_obj: Dict[str, Any]) -> None:
 38        """Adds a span to the grid."""
 39        self.grid.addSpan(js.JSON.parse(json.dumps(span_obj)))
 40
 41    def adjust_column_width(self, col_id: Union[str, int], adjust: Union[str, bool] = None) -> None:
 42        """Adjusts the width of a column."""
 43        self.grid.adjustColumnWidth(col_id, adjust)
 44
 45    def destructor(self) -> None:
 46        """Destroys the grid instance and releases resources."""
 47        self.grid.destructor()
 48
 49    def edit_cell(self, row_id: Union[str, int], col_id: Union[str, int], editor_type: str = None) -> None:
 50        """Enables editing of a grid cell."""
 51        self.grid.editCell(row_id, col_id, editor_type)
 52
 53    def edit_end(self, without_save: bool = False) -> None:
 54        """Finishes editing in a cell."""
 55        self.grid.editEnd(without_save)
 56
 57    def get_cell_rect(self, row_id: Union[str, int], col_id: Union[str, int]) -> Dict[str, Any]:
 58        """Returns the parameters of a cell."""
 59        rect = self.grid.getCellRect(row_id, col_id)
 60        return rect.to_py()
 61
 62    def get_column(self, col_id: Union[str, int]) -> Dict[str, Any]:
 63        """Returns an object with attributes of a column."""
 64        column = self.grid.getColumn(col_id)
 65        return column.to_py()
 66
 67    def get_header_filter(self, col_id: Union[str, int]) -> Any:
 68        """Returns an object with methods for the header filter of the specified column."""
 69        return self.grid.getHeaderFilter(col_id)
 70
 71    def get_scroll_state(self) -> Dict[str, int]:
 72        """Returns the coordinates of the scroll position."""
 73        state = self.grid.getScrollState()
 74        return state.to_py()
 75
 76    def get_sorting_state(self) -> Dict[str, Any]:
 77        """Returns the current state of sorting data in the grid."""
 78        state = self.grid.getSortingState()
 79        return state.to_py()
 80
 81    def get_span(self, row_id: Union[str, int], col_id: Union[str, int]) -> Dict[str, Any]:
 82        """Returns an object with spans."""
 83        span = self.grid.getSpan(row_id, col_id)
 84        return span.to_py()
 85
 86    def hide_column(self, col_id: Union[str, int]) -> None:
 87        """Hides a column of the grid."""
 88        self.grid.hideColumn(col_id)
 89
 90    def hide_row(self, row_id: Union[str, int]) -> None:
 91        """Hides a row of the grid."""
 92        self.grid.hideRow(row_id)
 93
 94    def is_column_hidden(self, col_id: Union[str, int]) -> bool:
 95        """Checks whether a column is hidden."""
 96        return self.grid.isColumnHidden(col_id)
 97
 98    def is_row_hidden(self, row_id: Union[str, int]) -> bool:
 99        """Checks whether a row is hidden."""
100        return self.grid.isRowHidden(row_id)
101
102    def paint(self) -> None:
103        """Repaints the grid on the page."""
104        self.grid.paint()
105
106    def remove_cell_css(self, row_id: Union[str, int], col_id: Union[str, int], css: str) -> None:
107        """Removes a CSS class from a cell."""
108        self.grid.removeCellCss(row_id, col_id, css)
109
110    def remove_row_css(self, row_id: Union[str, int], css: str) -> None:
111        """Removes a CSS class from a row."""
112        self.grid.removeRowCss(row_id, css)
113
114    def remove_span(self, row_id: Union[str, int], col_id: Union[str, int]) -> None:
115        """Removes a span from the grid."""
116        self.grid.removeSpan(row_id, col_id)
117
118    def scroll(self, x: int = None, y: int = None) -> None:
119        """Scrolls the grid to the specified coordinates."""
120        self.grid.scroll(x, y)
121
122    def scroll_to(self, row_id: Union[str, int], col_id: Union[str, int]) -> None:
123        """Scrolls the grid to a specified cell."""
124        self.grid.scrollTo(row_id, col_id)
125
126    def set_columns(self, columns: List[Dict[str, Any]]) -> None:
127        """Sets configuration for grid columns."""
128        self.grid.setColumns(js.JSON.parse(json.dumps(columns)))
129
130    def show_column(self, col_id: Union[str, int]) -> None:
131        """Shows a hidden column."""
132        self.grid.showColumn(col_id)
133
134    def show_row(self, row_id: Union[str, int]) -> None:
135        """Shows a hidden row."""
136        self.grid.showRow(row_id)
137
138    """ Grid Event Handlers """
139
140    def add_event_handler(self, event_name: str, handler: Callable) -> None:
141        """Adds an event handler for the specified event."""
142        event_proxy = create_proxy(handler)
143        self.grid.events.on(event_name, event_proxy)
144
145    # Example event: afterEditEnd
146    def on_after_edit_end(self, handler: Callable[[Any, Dict[str, Any], Dict[str, Any]], None]) -> None:
147        """Fires after editing of a cell is ended."""
148        def event_handler(value, row, column):
149            handler(value, row.to_py(), column.to_py())
150        self.grid.events.on('afterEditEnd', create_proxy(event_handler))
151
152    def on_cell_click(self, handler: Callable[[Dict[str, Any], Dict[str, Any], Any], None]) -> None:
153        """Fires when a cell is clicked."""
154        def event_handler(row, column, event):
155            handler(row.to_py(), column.to_py(), event)
156        self.grid.events.on('cellClick', create_proxy(event_handler))
157
158    def on_cell_dbl_click(self, handler: Callable[[Dict[str, Any], Dict[str, Any], Any], None]) -> None:
159        """Fires when a cell is double-clicked."""
160        def event_handler(row, column, event):
161            handler(row.to_py(), column.to_py(), event)
162        self.grid.events.on('cellDblClick', create_proxy(event_handler))
163
164    def on_cell_mouse_down(self, handler: Callable[[Dict[str, Any], Dict[str, Any], Any], None]) -> None:
165        """Fires before releasing the left mouse button when clicking on a grid cell."""
166        def event_handler(row, column, event):
167            handler(row.to_py(), column.to_py(), event)
168        self.grid.events.on('cellMouseDown', create_proxy(event_handler))
169
170    def on_cell_mouse_over(self, handler: Callable[[Dict[str, Any], Dict[str, Any], Any], None]) -> None:
171        """Fires on moving the mouse pointer over a grid cell."""
172        def event_handler(row, column, event):
173            handler(row.to_py(), column.to_py(), event)
174        self.grid.events.on('cellMouseOver', create_proxy(event_handler))
175
176    def on_cell_right_click(self, handler: Callable[[Dict[str, Any], Dict[str, Any], Any], None]) -> None:
177        """Fires on right click on a grid cell."""
178        def event_handler(row, column, event):
179            handler(row.to_py(), column.to_py(), event)
180        self.grid.events.on('cellRightClick', create_proxy(event_handler))
181
182    """ Grid Drag-and-Drop Event Handlers """
183
184    def on_before_row_drag(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
185        """Fires before dragging a row starts."""
186        def event_handler(data, event):
187            handler(data.to_py(), event)
188        self.grid.events.on('beforeRowDrag', create_proxy(event_handler))
189
190    def on_after_row_drag(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
191        """Fires after dragging a row finishes."""
192        def event_handler(data, event):
193            handler(data.to_py(), event)
194        self.grid.events.on('afterRowDrag', create_proxy(event_handler))
195
196    def on_before_column_drag(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
197        """Fires before dragging a column starts."""
198        def event_handler(data, event):
199            handler(data.to_py(), event)
200        self.grid.events.on('beforeColumnDrag', create_proxy(event_handler))
201
202    def on_after_column_drag(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
203        """Fires after dragging a column finishes."""
204        def event_handler(data, event):
205            handler(data.to_py(), event)
206        self.grid.events.on('afterColumnDrag', create_proxy(event_handler))
207
208    def on_row_drop(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
209        """Fires when a row is dropped."""
210        def event_handler(data, event):
211            handler(data.to_py(), event)
212        self.grid.events.on('afterRowDrop', create_proxy(event_handler))
213
214    def on_column_drop(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
215        """Fires when a column is dropped."""
216        def event_handler(data, event):
217            handler(data.to_py(), event)
218        self.grid.events.on('afterColumnDrop', create_proxy(event_handler))
219
220    # Dragging callbacks
221    def on_drag_row_in(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
222        """Fires when a row is dragged over a potential target."""
223        def event_handler(data, event):
224            handler(data.to_py(), event)
225        self.grid.events.on('dragRowIn', create_proxy(event_handler))
226
227    def on_drag_row_out(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
228        """Fires when a row is dragged out of a potential target."""
229        def event_handler(data, event):
230            handler(data.to_py(), event)
231        self.grid.events.on('dragRowOut', create_proxy(event_handler))
232
233    def on_drag_column_in(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
234        """Fires when a column is dragged over a potential target."""
235        def event_handler(data, event):
236            handler(data.to_py(), event)
237        self.grid.events.on('dragColumnIn', create_proxy(event_handler))
238
239    def on_drag_column_out(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
240        """Fires when a column is dragged out of a potential target."""
241        def event_handler(data, event):
242            handler(data.to_py(), event)
243        self.grid.events.on('dragColumnOut', create_proxy(event_handler))
244
245    def on_drag_row_start(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
246        """Fires when the dragging of a row starts."""
247        def event_handler(data, event):
248            handler(data.to_py(), event)
249        self.grid.events.on('dragRowStart', create_proxy(event_handler))
250
251    def on_drag_column_start(self, handler: Callable[[Dict[str, Any], Dict[str, Any]], None]) -> None:
252        """Fires when the dragging of a column starts."""
253        def event_handler(data, event):
254            handler(data.to_py(), event)
255        self.grid.events.on('dragColumnStart', create_proxy(event_handler))
256
257    # Similarly, other events can be added following the documentation provided.
258
259    """ Grid Selection Functions """
260
261    def select_cell(self, row: Union[Dict[str, Any], str, int] = None, column: Union[Dict[str, Any], str, int] = None,
262                    ctrl_up: bool = False, shift_up: bool = False) -> None:
263        """Sets selection to specified cells."""
264        self.grid.selection.setCell(row, column, ctrl_up, shift_up)
265
266    def get_selected_cells(self) -> List[Dict[str, Any]]:
267        """Returns an array with config objects of selected cells."""
268        cells = self.grid.selection.getCells()
269        return [cell.to_py() for cell in cells]
270
271    def unselect_cell(self, row_id: Union[str, int] = None, col_id: Union[str, int] = None) -> None:
272        """Unselects previously selected cells."""
273        self.grid.selection.removeCell(row_id, col_id)
274
275    """ Grid Export Functions """
276
277    def export_to_csv(self, config: Dict[str, Any] = None) -> str:
278        """Exports data from the grid into a CSV string or file."""
279        if config is None:
280            config = {}
281        result = self.grid.csv(js.JSON.parse(json.dumps(config)))
282        return result
283
284    def export_to_pdf(self, config: Dict[str, Any] = None) -> None:
285        """Exports data from the grid to a PDF file."""
286        if config is None:
287            config = {}
288        self.grid.pdf(js.JSON.parse(json.dumps(config)))
289
290    def export_to_png(self, config: Dict[str, Any] = None) -> None:
291        """Exports data from the grid to a PNG file."""
292        if config is None:
293            config = {}
294        self.grid.png(js.JSON.parse(json.dumps(config)))
295
296    def export_to_xlsx(self, config: Dict[str, Any] = None) -> None:
297        """Exports data from the grid to an Excel file."""
298        if config is None:
299            config = {}
300        self.grid.xlsx(js.JSON.parse(json.dumps(config)))