-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy pathPyEd.html
More file actions
1836 lines (1811 loc) · 149 KB
/
PyEd.html
File metadata and controls
1836 lines (1811 loc) · 149 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>PyEd.pyi</title>
<style>
body {
background-color: #1e1e1e;
color: #d4d4d4;
font-family: Consolas, monospace;
margin: 2em;
}
a {
color: #569cd6;
}
.class {
margin-bottom: 1em;
}
summary {
font-weight: bold;
font-size: 1.1em;
cursor: pointer;
padding: 0.2em 0.4em;
border-radius: 4px;
}
details {
margin-left: 0.5em;
background-color: #252526;
border: 1px solid #3c3c3c;
border-radius: 6px;
padding: 0.5em;
}
code {
display: block;
margin: 0.3em 0;
white-space: pre;
background-color: #1e1e1e;
color: #dcdcdc;
padding: 0.4em 0.6em;
border-left: 4px solid #007acc;
font-size: 1.2em;
}
.kw {
color: #569cd6;
font-weight: bold;
}
.ds {
color: #FF8787;
opacity: 0.7;
}
h1 {
color: #569cd6;
}
.tag {
background: #007acc;
color: #fff;
border-radius: 4px;
padding: 0.1em 0.5em;
font-size: 0.9em;
margin-left: 0.5em;
}
.toc {
margin-bottom: 2em;
}
</style>
</head>
<body>
<h1>PyEd.pyi</h1>
<div class="toc">
<h2>Classes</h2>
<ul>
<li><a href="#AutoSysVar">AutoSysVar</a></li>
<li><a href="#Core">Core</a></li>
<li><a href="#CursorType">CursorType</a></li>
<li><a href="#DragStatus">DragStatus</a></li>
<li><a href="#DragStyle">DragStyle</a></li>
<li><a href="#DragStyleType">DragStyleType</a></li>
<li><a href="#DrawJig">DrawJig</a></li>
<li><a href="#DrawOrderCmdType">DrawOrderCmdType</a></li>
<li><a href="#Editor">Editor</a></li>
<li><a href="#EditorReactor">EditorReactor</a></li>
<li><a href="#InputPoint">InputPoint</a></li>
<li><a href="#InputPointFilter">InputPointFilter</a></li>
<li><a href="#InputPointFilterResult">InputPointFilterResult</a></li>
<li><a href="#InputPointManager">InputPointManager</a></li>
<li><a href="#InputPointMonitor">InputPointMonitor</a></li>
<li><a href="#InputPointMonitorResult">InputPointMonitorResult</a></li>
<li><a href="#Jig">Jig</a></li>
<li><a href="#PointHistory">PointHistory</a></li>
<li><a href="#PromptCondition">PromptCondition</a></li>
<li><a href="#PromptStatus">PromptStatus</a></li>
<li><a href="#SelectionSet">SelectionSet</a></li>
<li><a href="#UIContext">UIContext</a></li>
<li><a href="#UserInputControls">UserInputControls</a></li>
<li><a href="#UserInteraction">UserInteraction</a></li>
<li><a href="#Util">Util</a></li>
</ul>
</div>
<div class="class" id="AutoSysVar">
<details>
<summary>class AutoSysVar <span class="tag">Class</span></summary>
<code><span class="kw">def</span> __init__(self, varName: str, value) -> None:</code>
<code><span class="kw">def</span> __reduce__(self) -> Any:</code>
<code><span class="kw">def</span> detach(self, val: bool) -> None:</code>
</details>
</div>
<div class="class" id="Core">
<details>
<summary>class Core <span class="tag">Class</span></summary>
<code><span class="kw">def</span> __init__(self) -> None:</code>
<code><span class="kw">def</span> __reduce__(self) -> Any:</code>
<code><span class="kw">def</span> addSupplementalCursorImage(image: wx.Image, order: int, alpha: int) -> bool:</code>
<code><span class="kw">def</span> alert(msg: str) -> int:
<span class="ds">Displays an alert box with an error or warning message. An alert box is a dialog box with a
single OK button. If you want the message to have multiple lines, you can include newline
characters (specified by n) in the string.</span></code>
<code><span class="kw">def</span> arxLoad(path: str) -> int:
<span class="ds">Loads an ARX module. Corresponds to the AutoLISP (arxload). acedArxLoad() returns an error
status code when the string parameter does not specify an existing file or when the file
cannot be loaded for some other reason.</span></code>
<code><span class="kw">def</span> arxLoaded() -> list:
<span class="ds">Returns a pointer to a list of the external ARX applications that are currently loaded. The
name of each application is returned as a string in its own result buffer
(resval->rstring). If no external applications are currently loaded, acedArxLoaded()
returns NULL.</span></code>
<code><span class="kw">def</span> arxUnload(app: str) -> int:
<span class="ds">Unloads an ARX module. Corresponds to the AutoLISP (arxunload) function. The
acedArxUnload() function returns an error status code when the string parameter does not
specify a loaded ARX program or when the program to be unloaded has dependents registered
on its services.</span></code>
<code><span class="kw">def</span> audit(db: PyDb.Database, fix: bool, echo: bool) -> None:
<span class="ds">This function audits the AcDbDatabase pointed to by pDb.</span></code>
<code><span class="kw">def</span> autoSetVar(name: str, value) -> AutoSysVar:</code>
<code><span class="kw">def</span> calcTextExtents(val: str, textStyleId: PyDb.ObjectId) -> tuple[float, float]:</code>
<code><span class="kw">def</span> callBackOnCancel() -> None:
<span class="ds">If you have made a call to acedCommandC or acedCmdC and wish to have your registered
callback called when a CANCEL or other error occurs, call this function before returning.
If you don't call this function and a CANCEL or other error occurs, your callback will not
be called, instead AutoCAD will directly cancel the command state.</span></code>
<code><span class="kw">def</span> clearOLELock(handle: int) -> bool:
<span class="ds">This function is for use with OLE Automation applications. Whenever such an application
uses any of the ObjectARX API functions, it must call acedSetOLELock() to set a lock. When
the lock is set, the application calls this function to clear the lock and allow other OLE
applications their chance to lock and use ObjectARX API functions. handle is a lock 'code'
integer that is used to make sure that the setting and clearing of the lock are done by the
same application. Both acedSetOLELock() and this function must be passed this integer lock
code as an identifier. If handle is a different code than was used to set the lock, then
the clear attempt will fail. Returns Adesk::kTrue is the lock is successfully cleared,
otherwise returns Adesk::kFalse.</span></code>
<code><span class="kw">def</span> clipFormatName() -> str:
<span class="ds">Returns the clipboard format name string for the product. This string is the same for all
AutoCAD based products, but is different for OEM and LT products. This function replaces
the CF_AUTOCAD macro.</span></code>
<code><span class="kw">def</span> cmdCWasCancelled() -> bool:
<span class="ds">When your registered callback is called in response to a CANCEL or error, this function
will return true, else it will return false.</span></code>
<code><span class="kw">def</span> cmdS(commandName: str) -> bool:
<span class="ds">This function does the same thing with the same restructions as acedCommandS, with a resbuf
chain rather than a veriable arguments list. Two more supplied parameters are intended for
future use.</span></code>
<code><span class="kw">def</span> cmdS(resultBuffer: list[tuple[int, Any]]) -> bool:
<span class="ds">This function does the same thing with the same restructions as acedCommandS, with a resbuf
chain rather than a veriable arguments list. Two more supplied parameters are intended for
future use.</span></code>
<code><span class="kw">def</span> cmdS(*args) -> bool:
<span class="ds">This function does the same thing with the same restructions as acedCommandS, with a resbuf
chain rather than a veriable arguments list. Two more supplied parameters are intended for
future use.</span></code>
<code><span class="kw">def</span> cmdUndefine(name: str, undefineit: int) -> int:
<span class="ds">This function searches the command stack of registered commands for the command name cmdstr
and if found sets (if undefit == 1) or unsets (if undefit == 0) the 'undefine' bit in the
command flags for that command. If the 'undefine' bit is set, then AutoCAD will treat this
command as though it is undefined in the same way that internal AutoCAD commands are
treated if they have been undefined via the AutoCAD UNDEFINE command.</span></code>
<code><span class="kw">def</span> convertEntityToHatch(hatch: PyDb.Hatch, entity: PyDb.Entity, transferId: bool) -> None:
<span class="ds">Converts a block reference or a solid to a hatch. If transferId is true, the calling
AcDbHatch assumes the AcDbObjectId, handle, any extended entity data, extension
dictionaries, or reactors, as well as any hatch associativity of pEnt. This is the only way
the associativity with the boundary objects can be transferred. pEnt will then be deleted
and set to NULL. If transferId is false, pEnt remains in the database as is and the caller
is responsible for closing it. The resulting AcDbHatch is not database-resident and, as
such, cannot assume any of the associativity with pEnt boundary objects. The caller can
later call pEnt->handOverTo() to exchange the new AcDbHatch for pEnt in the database, but
the associativity cannot be re-established.</span></code>
<code><span class="kw">def</span> coordFromPixelToWorld(pt: tuple[int, int]) -> PyGe.Point3d:
<span class="ds">Converts coordinates from AutoCAD drawing window to current active viewport's coordinates.
Returns TRUE if it successfully converts the coordinates; otherwise, it returns FALSE.</span></code>
<code><span class="kw">def</span> coordFromPixelToWorld(winnum: int, pt: tuple[int, int]) -> PyGe.Point3d:
<span class="ds">Converts coordinates from AutoCAD drawing window to current active viewport's coordinates.
Returns TRUE if it successfully converts the coordinates; otherwise, it returns FALSE.</span></code>
<code><span class="kw">def</span> coordFromPixelToWorld(*args) -> PyGe.Point3d:
<span class="ds">Converts coordinates from AutoCAD drawing window to current active viewport's coordinates.
Returns TRUE if it successfully converts the coordinates; otherwise, it returns FALSE.</span></code>
<code><span class="kw">def</span> coordFromWorldToPixel(windnum: int, pnt: PyGe.Point3d) -> tuple[int, int]:
<span class="ds">Converts coordinates in given viewport to Windows screen coordinates. Returns TRUE if it
successfully converts the coordinates; otherwise, returns FALSE.</span></code>
<code><span class="kw">def</span> createInternetShortcut(szURL: str, szShortcutPath: str) -> bool:
<span class="ds">Creates an MSIE-compatible Internet shortcut using the arguments passed to it.</span></code>
<code><span class="kw">def</span> createViewportByView(db: PyDb.Database, view: PyDb.ObjectId, pt: PyGe.Point2d, scale: float) -> PyDb.ObjectId:
<span class="ds">This function creates a viewport for the given model view at the desired location. It bases
the size of the viewport on the scale factor and the size of the model view. For example, a
model view 20 feet across and a scale of one foot to a quarter inch would yield a viewport
that was five inches across on the paper of the layout. This call assumes that the viewport
is being created in the current layout. Returns eOk on success. Possible error codes
include Acad::eNotInPaperspace if not currently in a layout, Acad::eWrongDatabase if the
AcDbDatabase passed in was not the current database, various open errors if the
AcDbViewTableRecord could not be opened, or Acad::eInvalidInput if another error occurred
preventing the creation of the viewport.</span></code>
<code><span class="kw">def</span> curDwgXrefGraph() -> PyDb.XrefGraph:</code>
<code><span class="kw">def</span> defun(name: str, funcnumber: int) -> int:
<span class="ds">Defines an ARX application function as an external AutoLISP function and clears any
existing acedSetFunHelp() reference. Once a function in an ARX application has been defined
by a call to acedDefun(), it can be called from AutoLISP. When AutoLISP sends an
kInvkSubrMsg message to the application, the funcno for the function can be retrieved by a
call to acedGetFunCode(), and any arguments can be retrieved by a call to acedGetArgs(). As
in AutoLISP, if the first characters of sname are C:, you can invoke the function as an
AutoCAD command without enclosing its name in parentheses. You can invoke it also as a
function, provided that the prefix C: is included as part of its name. Warning If two or
more external applications define functions that have the same name, AutoLISP can recognize
only the most recently defined external function. The previously loaded function will be
lost. The acedSetFunHelp() function is usually called directly after acedDefun() to
register command line help for the defined function. AutoLISP saves function and command
names in uppercase characters, but if pszName is lowercase, acedDefun() converts it before
passing it to AutoLISP. AutoLISP binds functions defined by acedDefun() to the Exsubr
symbol type. Warning If the application defines a C:XXX command whose name conflicts with a
built-in command or with a command name defined in the acad.pgp file, AutoCAD does not
recognize the external function as a command (though it can still be invoked as an AutoLISP
external function). For example, after the call to acedDefun('c:cp', 0), a user input of cp
invokes the AutoCAD COPY command (this alias is defined in the sample acad.pgp), but the
user could invoke the external function with (c:cp). Function names defined by acedDefun()
can be undefined by calling acedUndef(). This removes the function name from the AutoLISP
atom list. After a function has been undefined, an attempt to invoke it causes an error. If
acedDefun() succeeds, it returns RTNORM; otherwise, it returns an error code.</span></code>
<code><span class="kw">def</span> defunEx(globalName: str, name: str, funcnumber: int) -> int:
<span class="ds">Defines an ARX application function as an external AutoLISP function and clears any
existing acedSetFunHelp() references. It is similar to acedDefun(), but takes both global
and local name arguments. If you want to set up global and local names for the same
function, please use a single call to acedDefunEx(), rather than two calls to acedDefun().
Once a function in an ARX application has been defined by a call to acedDefunEx(), it can
be called from AutoLISP. When AutoLISP sends an kInvkSubrMsg message to the application,
the nFuncNum for the function can be retrieved by a call to acedGetFunCode(), and any
arguments can be retrieved by a call to acedGetArgs(). As in AutoLISP, if the first
characters of the name are C:, you can invoke the function as an AutoCAD command without
enclosing its name in parentheses. You can invoke it also as a function, provided that the
prefix C: is included as part of its name. Warning: If two or more external applications
define functions that have the same name, AutoLISP can recognize only the most recently
defined external function. The previously loaded function will be lost. The
acedSetFunHelp() function is usually called directly after acedDefunEx() to register
command line help for the defined function. It is also common to call acedRegFunc()
immedately after acedDefunEx(). This frees your application from the need to handle
kInvkSubrMsg messages. AutoLISP saves function and command names in uppercase characters,
but if the name is lowercase, acedDefunEx() converts it before passing it to AutoLISP.
AutoLISP binds functions defined by acedDefunEx() to the Exsubr symbol type. Warning: If
the application defines a C:XXX command whose name conflicts with a built-in command or
with a command name defined in the acad.pgp file, AutoCAD does not recognize the external
function as a command (though it can still be invoked as an AutoLISP external function).
For example, after the call to acedDefunEx('c:cp', 0), a user input of cp invokes the
AutoCAD COPY command (this alias is defined in the sample acad.pgp), but the user could
invoke the external function with (c:cp). Function names defined by acedDefunEx() can be
undefined by calling acedUndef(). This removes the function name from the AutoLISP atom
list. After a function has been undefined, an attempt to invoke it causes an error.</span></code>
<code><span class="kw">def</span> disableDefaultARXExceptionHandler(val: bool) -> None:
<span class="ds">This function will disable (if disable is Adesk::kTrue) or enable (if disable is
Adesk::kFalse) exception handling in AutoCAD for exceptions thrown while code is executing
in an ObjectARX or ObjectDBX module. When AutoCAD starts up, this exception handling is
enabled. Disabling this exception handling allows applications to do their own exception
handling of exceptions thrown while an ObjectARX or ObjectDBX module is executing.</span></code>
<code><span class="kw">def</span> disableUsrbrk() -> None:
<span class="ds">This function disables the user break mechanism for the current document.</span></code>
<code><span class="kw">def</span> displayBorder(val: bool) -> bool:
<span class="ds">Shows or hides a blue border around the inner edge of the drawing area of the current
window. This behavior is used with the Drawing Compare feature (COMPARE command).</span></code>
<code><span class="kw">def</span> drawOrderInherit(parent: PyDb.ObjectId, childids: list[PyDb.ObjectId], cmd: PyEd.DrawOrderCmdType) -> None:
<span class="ds">This function is called to set the draw order on a new child array object or objects. It
should be called after the child array objects are added to the database, but before they
are regen'ed, so that they are regen'ed to the proper location the first time. If cmd
argument is kDrawOrderBelow or kDrawOrderAbove, then a valid parent ID must be supplied,
and children objects are placed either just below or just above the parent entity,
visually. If the cmd argument is kDrawOrderTop or kDrawOrderBottom, the parent entity can
be null and any parent value is ignored because the entity is moving to the very top or
bottom of draw order. The parent and all child entities must all be in the same space
(model, paper, or a given block).</span></code>
<code><span class="kw">def</span> drawingStatusBarsVisible() -> bool:
<span class="ds">This global method returns a value indicating whether or not the drawing status bars are
visible in AutoCAD. By default, the drawing status bars are hidden in AutoCAD. Use this
method to query the display state of the drawing status bars. If the display state is
FALSE, acedShowDrawingStatusBars() can be used to display the drawing status bars in
AutoCAD.</span></code>
<code><span class="kw">def</span> dropOpenFile(val: str) -> None:</code>
<code><span class="kw">def</span> eatCommandThroat() -> int:
<span class="ds">For internal use only.</span></code>
<code><span class="kw">def</span> editMTextInteractive(mt: PyDb.MText, usenewUI: bool, allowTabs: bool) -> int:
<span class="ds">Invokes the MTEXT user interface.</span></code>
<code><span class="kw">def</span> enableUsrbrk() -> None:
<span class="ds">This function enables the user break mechanism for the the current document.</span></code>
<code><span class="kw">def</span> evaluateDiesel(statement: str) -> str:</code>
<code><span class="kw">def</span> evaluateLisp(statement: str) -> list:</code>
<code><span class="kw">def</span> exceptionTest() -> str:</code>
<code><span class="kw">def</span> findFile(fname: str) -> str:
<span class="ds">Deprecated. Searches for the specified file. The result argument must point to a buffer
large enough to hold the qualified file name: depending on the directory structure of the
current environment, this can be quite long. The maximum length of result is platform
dependent. On platforms that restrict file-name length, it is 78 characters; on platforms
that don't restrict file-name length, it is 511. This function makes no assumption about
the type of the file, and does not attempt to append any kind of file-name extension. If
the file you are searching for does have an extension to its name, the extension must be
included in the fname argument. If fname is qualified by including a drive or directory
prefix (for example, 'd:test.exp'), acedFindFile() searches only that disk or directory.
Otherwise, acedFindFile() searches for fname according to the current AutoCAD library path,
which consists of the following directories, in order: The current directoryThe directory
that contains the current drawing fileThe directories named by the ACAD environment
variable (if this variable has been specified)The directory that contains the AutoCAD
program files Depending on the current environment, two or more of these directories may be
the same. If acedFindFile() finds the file, it returns RTNORM; otherwise, it returns
RTERROR.</span></code>
<code><span class="kw">def</span> findTrustedFile(fname: str) -> str:
<span class="ds">Deprecated. Searches the AutoCAD trusted file paths for the specified file. The command
looks for the file in the regular AutoCAD search path. If a match is found, it verifies if
the file path is part of trustedpaths. If the file is not present in any of the directories
in the trusted file paths, the function returns NULL</span></code>
<code><span class="kw">def</span> getAcadDockCmdLine() -> int:
<span class="ds">This function is used to get the AutoCAD's Command Line window. For building ObjectARX
applications with a static MFC library, or when not using the same shared MFC DLL as
AutoCAD, a pointer to a window cannot be used. Instead, use the window handle. To get the
window handle, use acedGetAcadDockCmdLine()->m_hWnd;</span></code>
<code><span class="kw">def</span> getAcadTextCmdLine() -> int:
<span class="ds">This function is used to get the AutoCAD's Text Command Line window. For building ObjectARX
applications with a static MFC library, or when not using the same shared MFC DLL as
AutoCAD, a pointer to a window cannot be used. Instead, use the window handle. To get the
window handle, use acedGetAcadTextCmdLine()->m_hWnd;</span></code>
<code><span class="kw">def</span> getBlockEditMode() -> int:
<span class="ds">This function returns the current BlockEdit mode value. The possible values are defined in
the BlockEditModeFlags enum. The returned value may be a bitwise combination of the various
enum values.</span></code>
<code><span class="kw">def</span> getCfg(val: str) -> str:
<span class="ds">Deprecated. Retrieves application data from the AppData section of the acad.cfg file.</span></code>
<code><span class="kw">def</span> getCommandForDocument(doc: PyAp.Document) -> str:
<span class="ds">Gets the global or local name of the innermost current command for the given document.</span></code>
<code><span class="kw">def</span> getCommandPromptString() -> str:</code>
<code><span class="kw">def</span> getCommands() -> dict:</code>
<code><span class="kw">def</span> getCurVportPixelToDisplay() -> tuple[float, float]:
<span class="ds">This function sets xFactor and yFactor to the x and y pixel space to display space
conversion factors for the current viewport. These values represent the size of a pixel in
display coordinates. If there is no current viewport, then both are set to 0.0.</span></code>
<code><span class="kw">def</span> getCurVportScreenToDisplay() -> tuple[float, float]:
<span class="ds">This function sets xFactor and yFactor to the x and y screen space to display space
conversion factors for the current viewport. If there is no current viewport, then both are
set to 0.0.</span></code>
<code><span class="kw">def</span> getCurrentSelectionSet() -> list[PyDb.ObjectId]:
<span class="ds">This function fills sset in with the object IDs of all entities in the current selection
set within AutoCAD. The 'current selection set' may be one of the following: a pickfirst
set, a selection set selected by the select command or any other command that does a
selection (that is, similar to the 'Previous' selection option), or the most recent set
from an ssget. If a pickfirst set is available it will always be used. If no pickfirst set
is available, then whichever of the other two types is available will be used. If both of
the other two types are available, then whichever was most recently created will be used.
If a pickfirst selection set is 'selected' by a call to this function, then the entity
highlighting and grips will disappear just as they would when any AutoCAD command uses a
pickfirst selection set. If an ssget type of selection is 'selected' by a call to this
function, then sset will essentially be a copy of the selection set and the original ssget
selection set will still be valid. Only certain AutoCAD commands create a selection set
that can be found by acdbGetCurrentSelectionSet(). These commands are listed below: ACISOUT
AMECONVERT ARRAY ATTEXT AUDIT BHATCH BMPOUT CHANGE CHPROP CONVERT CONVERTPOLY COPY COPYCLIP
CUTCLIP DIVIDE DVIEW DXFOUT (partial) ERASE EXPLODE EXTEND EXTRUDE GROUP HATCH HIDE
INTERFERE INTERSECT LIST MASSPROP MEASURE MIRROR MOVE MVIEW OOPS PEDIT REGION REVOLVE
ROTATE SCALE SECTION SELECT SLICE SPELL SPLINE STLOUT STRETCH SUBTRACT TRIM UNION VPVIS
WBLOCK WMFOUT XCLIP</span></code>
<code><span class="kw">def</span> getCurrentView() -> PyDb.ViewTableRecord:</code>
<code><span class="kw">def</span> getDpiScalingValue() -> float:
<span class="ds">Returns DPI scaling value for Windows system. Returns 1.0 on Mac platform.</span></code>
<code><span class="kw">def</span> getEnv(val: str) -> str:
<span class="ds">Deprecated. Retrieves the value of an environment variable. Looks first in the
AutoCAD-specific FixedProfile/General section of the registry: HKEY_CURRENT_USER Software
Autodesk AutoCAD R25.0 <Install ID> FixedProfile GeneralIf an entry is not found in the
registry, retrieves the value from the Windows system environment table.</span></code>
<code><span class="kw">def</span> getFileD(title: str, defawlt: str, ext: str, flags: int) -> str:
<span class="ds">Prompts the user for a file name with the standard AutoCAD file dialog box.WarningThis
function must never be called in zero-document state. Always check to see if any documents
are loaded in the editor before calling this function. You can do this with the
AcApDocManager::curDocument() function, which returns null if no documents are opened in
the editor. The title argument specifies the caption of the entire dialog box, defawlt
specifies the default file name (which can be NULL), and ext is the default file-name
extension (if passed as NULL, ext defaults to *). If the default file name is NULL or
specifies only a path, the Default button in the dialog box is disabled. Beginning with
AutoCAD Release 13, the ext argument accepts multiple filename extensions separated by
semicolons, as shown in the following example call to acedGetFileD(): const char* filea =
'myfile.dwg';result = acutNewRb(RTSTR);acedGetFileD(filea, NULL, 'dwg;eps;abc', 33,
result);If the dialog box gets a filename from the user, acedGetFileD() sets the string in
the result argument to a string specifying the filename. The acedGetFileD() function
allocates memory for the pathname string. Your program is responsible for freeing the
string by calling free() (if result is a static buffer) or acutRelRb() (if result is a
dynamically allocated resbuf). The maximum length of a pathname is platform dependent. On
platforms that restrict filename length, it is 78 characters; on platforms that don't
restrict filename length, it is 511. The effects of user responses are defined in the
following ways: Response Action OK Prevents the function from returning unless a file name
is selected Cancel Returns RTERROR Help Brings up the help dialog box but doesn't close
acedGetFileD() The flags argument is a bit-coded field that controls the behavior of the
dialog box. To set more than one condition at a time, add the values together to create a
flags value between 0 and 127. The control bits have the following meanings: Value Use
Description Bit 0 (= 1 if set) Indicates a request to create a new file Set this bit when
you include a prompt for the name of a new file to create. Leave bit 0 set to 0 when you
include a prompt for the name of an existing file to open. In this case, if the user enters
the name of a nonexistent file, the dialog box displays an error message at the bottom of
the box.If bit 0 is set (create) and the user enters an existing file name for a new file,
acedGetFileD() displays an alert box to warn the user that the file exists and to offer the
choice of proceeding with or canceling the operation.If bit 0 is not set (open) and bit 2
is not set, only the default extension (or none) is accepted. If no extension is entered,
the default extension is automatically used. If the user enters any extension other than
the default, an 'Invalid filename' message box is displayed and the user is required to try
again or cancel.If bit 0 is set (create) and bit 2 is not set, the default extension is
added if it is not entered as part of the file name.</span></code>
<code><span class="kw">def</span> getFileNavDialog(title: str, defawlt: str, ext: str, dlgname: str, flags: int) -> list:
<span class="ds">The acedGetFileNavDialog() function prompts the user for a file name using the AutoCAD file
navigation dialog box. The title argument specifies the caption of the entire dialog box;
default specifies the default file name (which can be null); and ext is the default file
name extension (if passed as null, ext defaults to '*'). The ext argument accepts multiple
file name extensions separated by semicolons, as shown in the following example call to
acedGetFileNavDialog(): const ACHAR * filea = 'myfile.dwg';const ACHAR * dlgname = 'My File
Dialog';struct resbuf* result = NULL;acedGetFileNavDialog(filea, NULL, 'dwg;eps;abc',
dlgname, 33, &result);//... do whatever with resultacutRelRb(result); The dlgname argument
specifies a name for the dialog. This name is used as a key in the Windows registry for
saving dialog-persistent data such as size and position. For example, in the code above,
the dialog's position and size are stored in the user's profile under the Dialogs>My File
Dialog key. If the dialog box gets a file name (or names) or a folder name from the user,
acedGetFileNavDialog() allocates a resbuf chain for the result. Your program is responsible
for freeing the resbuf chain by calling acutRelRb(). The effects of user responses are
defined in the following ways: Response Action Open Prevents the function from returning
unless a file name is selected Cancel Returns RTERROR The flags argument is a bit-coded
field that controls the behavior of the dialog box. To set more than one condition at a
time, add the values together to create a flags value between 0 and 65535. The control bits
have the following meanings: Value Use Description Bit 0 (= 1 if set) Indicates a request
to create a new file Set this bit when you include a prompt for the name of a new file to
create. Leave bit 0 set to 0 when you include a prompt for the name of an existing file to
open. In this case, if the user enters the name of a nonexistent file, the dialog box
displays an error message at the bottom of the box.If bit 0 is set (create) and the user
enters an existing file name for a new file, acedGetFileNavDialog() displays an alert box
to warn the user that the file exists and to offer the choice of proceeding with or
canceling the operation.If bit 0 is not set (open) and bit 2 is not set, only the default
extension (or none) is accepted. If no extension is entered, the default extension is
automatically used. If the user enters any extension other than the default, an 'Invalid
filename' message box is displayed and the user is required to try again or cancel.If bit 0
is set (create) and bit 2 is not set, the default extension is added if it is not entered
as part of the file name.</span></code>
<code><span class="kw">def</span> getLastCommandLines(lineCount: int, ignoreNull: bool) -> list[str]:</code>
<code><span class="kw">def</span> getMousePositionUCS() -> PyGe.Point3d:</code>
<code><span class="kw">def</span> getMousePositionWCS() -> PyGe.Point3d:</code>
<code><span class="kw">def</span> getPredefinedHatchPatterns() -> list[str]:</code>
<code><span class="kw">def</span> getRGB(colorIndex: int) -> tuple[int, ...]:
<span class="ds">This function returns a RGB color value in Win32 COLORREF (0x00bbggrr) format for the color
specified by the AutoCAD Color Index (ACI) number. The ACI number must be a value between 0
and 255. If this function is passed a value less than 0 or greater than 255, then the
return value will be meaningless.</span></code>
<code><span class="kw">def</span> getSupplementalCursorOffset() -> tuple:</code>
<code><span class="kw">def</span> getSym(val: str) -> list:
<span class="ds">Retrieves the value of a bound AutoLISP symbol. This function can be used in the ARX
program environment only when AutoCAD sends the message kInvkSubrMsg to the application. If
the AutoLISP symbol is bound to a value of a type that can't be represented by a list of
ARX result buffers (such as a subr or exsubr), the acedGetSym() call fails. If the symbol
is not found or is nil, acedGetSym() returns RTNORM and sets the contents of value (*value)
to null. The acedGetSym() function returns RTNORM if it succeeds and RTERROR if it fails.
It returns RTMODELESS, if the active command was registered using the
ACRX_CMD_INTERRUPTIBLE flag and the document has received a modeless interrupt signal from
a call to AcApDocManager::sendModelessInterrupt(). When acedGetSym() fails, it sets the
system variable ERRNO to a value that indicates the reason for the failure.</span></code>
<code><span class="kw">def</span> getSysVars() -> dict:</code>
<code><span class="kw">def</span> getUserFavoritesDir() -> str:
<span class="ds">This function provides access to the Windows Favorites directory of the current user.</span></code>
<code><span class="kw">def</span> getVar(name: str) -> object:
<span class="ds">Retrieves the current value of the specified AutoCAD system variable. The result argument
must point to a resbuf structure, because the system variables consist of a variety of
types. Warning The result argument must point to an allocated resbuf (it can be static,
automatic, or dynamically allocated). It must not be declared as just a pointer; if the
application doesn't allocate enough space for the resbuf structure, acedGetVar() will
return garbage or corrupt other data in memory. If the requested system variable is a
string value, acedGetVar() dynamically allocates the memory needed to hold the string. The
ARX application is responsible for releasing this memory. This can be accomplished by a
call to the C utility function free(), or by a call to acutRelRb() if the buffer used for
the result argument was allocated dynamically. This function is the complement of the
acedSetVar() function. If acedGetVar() succeeds, it returns RTNORM; otherwise, it returns
an error code.</span></code>
<code><span class="kw">def</span> getWinNum(ptx: int, pty: int) -> int:
<span class="ds">Provide coordinates in AutoCAD drawing window (in client coordinates) and this function
will return the viewport number the coordinates correspond to. This function usually is
used with acedCoordFromWorldToPixel() or acedCoordFromPixelToWorld(). Returns the viewport
number based on Windows client coordinates.</span></code>
<code><span class="kw">def</span> grDraw(pt1: PyGe.Point2d | PyGe.Point3d, pt2: PyGe.Point2d | PyGe.Point3d, color: int, highlight: int) -> int:
<span class="ds">Draws a vector between two points in the current viewport. AutoCAD clips the vector as
required to fit the screen. Highlighting, controlled by the hl argument, depends on the
display device. Most display drivers indicate highlighting by a dashed line, but some
indicate it by using a distinctive color. Unless a critical error occurs, acedGrDraw()
returns RTNORM.</span></code>
<code><span class="kw">def</span> grDrawArc(pt1: PyGe.Point3d, pt2: PyGe.Point3d, pt3: PyGe.Point3d, numsegs: int, color: int) -> int:</code>
<code><span class="kw">def</span> grDrawBox(pts: list[PyGe.Point3d], color: int, highlight: int) -> int:</code>
<code><span class="kw">def</span> grDrawCircle(cen: PyGe.Point3d, radius: float, numsegs: int, color: int) -> int:</code>
<code><span class="kw">def</span> grDrawPoly2d(pts: list[PyGe.Point2d], color: int) -> int:</code>
<code><span class="kw">def</span> grDrawPoly3d(pts: list[PyGe.Point3d], color: int) -> int:</code>
<code><span class="kw">def</span> grText(box: int, text: str, hl: int) -> int:
<span class="ds">Displays the specified text in the menu, mode, or status area of the graphics screen. If
box equals the number of a screen menu box and hl is less than 0, acedGrText() displays
text in that box. The menu boxes are numbered beginning at 0. If the value of box is
greater than the number of menu boxes minus one, the call to acedGrText() usually has no
effect. If box specifies a screen menu box and hl is greater than 0, the text displayed by
acedGrText() is highlighted. If hl equals 0 and the box is highlighted, acedGrText() turns
highlighting off. (Remember that AutoCAD allows only one menu box to be highlighted at a
time. A call that highlights a different box automatically turns off any previous
highlighting.) When hl is greater than or equal to 0, the text argument is ignored. If box
equals -1, acedGrText() writes the text into the mode status line (the hl argument is
ignored). The length of the mode status line differs from display to display; most allow at
least 40 characters. If text contains more characters than the mode status line allows, it
is truncated; if it contains fewer characters, it is padded with blanks. If box equals -2,
acedGrText() writes the text into the coordinate status line (the hl argument is ignored).
If coordinate tracking is turned on, any value written into this field is overwritten as
soon as the pointer sends another set of coordinates. Finally, if box is less than -2 (for
example: box equals -5), acedGrText() restores all the text areas on the screen to their
standard values. If it succeeds, acedGrText() returns RTNORM. It returns RTERROR if the box
number is out of range.</span></code>
<code><span class="kw">def</span> grVecs(resbuf: list, xform: PyGe.Matrix3d) -> int:
<span class="ds">Draws multiple vectors on the graphics screen. Result-buffer elements in the vlist can be
as follows: A pair of points (RTPOINT or RT3DPOINT) that specify the endpoints of the
vector, expressed in the current UCS; these can be three-dimensional points.</span></code>
<code><span class="kw">def</span> graphScr() -> None:
<span class="ds">On single-screen AutoCAD installations, causes the display to switch from the text screen
to the graphics screen. This is equivalent to using the AutoCAD GRAPHSCR command or to
pressing the Flip Screen function key (when the text screen is current). The acedTextScr()
function is the complement of acedGraphScr(). If acedGraphScr() succeeds, it returns
RTNORM; otherwise, it returns an error code.</span></code>
<code><span class="kw">def</span> hasSupplementalCursorImage() -> bool:</code>
<code><span class="kw">def</span> hatchPalletteDialog(pattern: str, custom: bool) -> str:</code>
<code><span class="kw">def</span> initDialog(useDialog: bool) -> bool:
<span class="ds">This function sets an internal flag in AutoCAD so that when a command that has a dialog
that is normally not activated by LISP (such as the PLOT command) is run, the dialog will
be activated rather than using the command line interface. If useDialog is Adesk::kTrue,
then the next use (and next use only) of the command (such as PLOT) when run from LISP or
ObjectARX, will display the command's dialog rather than its command line prompts. If
useDialog is Adesk::kFalse, then any previous call to this function (or the LISP (initdia)
function) to tell AutoCAD to display dialogs will be cleared so that the default behavior
of presenting the command line interface will be restored. Returns the value that the
internal flag was set to before this function was called.</span></code>
<code><span class="kw">def</span> invoke(resultBuffer: list) -> list:
<span class="ds">Invokes an external function defined in another ARX application. When acedInvoke() returns
RTNORM, this implies that the external function was called and returned successfully. It
does not imply that the external function successfully obtained a result. To determine the
result, your program must inspect the result argument. If the external function failed or
returned no value, result will be NULL; otherwise, result points to a list of return
values. The external function being invoked must be an external function in an ARX
application currently loaded. From the external function's point of view, the acedInvoke()
call is invisible. It retrieves its arguments by calling acedGetArgs() and returns a value
by calling one of the value-return functions (acedRetInt(), acedRetReal(), and so on), as
it does when invoked by an AutoLISP function or by the AutoCAD user. Warning If the
external function being invoked has been registered (in its application) by a call to
acedRegFunc(), another function in the same application can call it--directly or
indirectly--with acedInvoke(). Otherwise, acedInvoke() returns RTERROR. This also applies
to a calling sequence that the first function initiates. If the calling chain leads back
into the same application, acedInvoke() returns RTERROR unless the function in the same
application has been registered by acedRegFunc(). To avoid acedInvoke() failure, be certain
that all external functions that are meant to be called by acedInvoke() are registered by a
call to acedRegFunc() after their application has successfully called acedDefun(). The
first result buffer in the args list must contain the name of the external function. If the
function was defined as an AutoCAD command, the string must include the C: prefix. The
remaining result buffers in the args list must match the external function's argument list
in their order, types, and value ranges. If the external function has called acedRetList(),
result points to a list of values.</span></code>
<code><span class="kw">def</span> isDragging() -> int:
<span class="ds">This function indicates whether dragging is occurring in AutoCAD's editor. Returns 0 if no
dragging is occurring, and a non-zero value otherwise.</span></code>
<code><span class="kw">def</span> isInBackgroundMode() -> bool:
<span class="ds">This function returns true if the AutoCAD session in which it is called is running in
background mode for plotting.</span></code>
<code><span class="kw">def</span> isInputPending() -> bool:
<span class="ds">This function should be called from a dialog after a user-interactive action has been
canceled. If this function returns false, the dialog should be restored. Otherwise, the
dialog should be terminated in order to allow the queued input to be processed by AutoCAD.</span></code>
<code><span class="kw">def</span> isMenuGroupLoaded(mnu: str) -> bool:
<span class="ds">This function checks to see if the menugroup pszGroupName is currently loaded in the
AutoCAD editor. Returns Adesk::kTrue if the pszGroupName menugroup is currently loaded, or
Adesk::kFalse if not.</span></code>
<code><span class="kw">def</span> isOsnapOverride() -> bool:
<span class="ds">Informs a custom Osnap routine whether it was called by a running Osnap or an Osnap
override. In other words, this function returns true if a custom Osnap routine was called
by an Osnap override.</span></code>
<code><span class="kw">def</span> isUpdateDisplayPaused() -> bool:
<span class="ds">Returns true if display updates are paused, or false otherwise. This function should be
used before calling acedUpdateDisplayPause(), to record the current update display pause
state and restore that when finished pausing the display. This prevents other users of
acedUpdateDisplayPause() from having the display re-enabled prematurely.</span></code>
<code><span class="kw">def</span> isUsrbrkDisabled() -> bool:
<span class="ds">This function returns true if the user break mechanism is enabled for the current document.</span></code>
<code><span class="kw">def</span> loadJSScript(scr: str) -> None:</code>
<code><span class="kw">def</span> loadMainMenu(mnu: str) -> bool:</code>
<code><span class="kw">def</span> loadPartialMenu(mnu: str) -> bool:
<span class="ds">Adds (loads) a partial menu to the current main menu.</span></code>
<code><span class="kw">def</span> mSpace() -> None:
<span class="ds">When called in a layout, this function switches the editor to model space. Returns
Acad::eOk if successful, or if the editor is already in model space. Returns
Acad::eInvalidInput if TILEMODE is set to 1, or if there is no current drawing. Returns
Acad::eCannotChangeActiveViewport if no on-screen viewports are available for switching.</span></code>
<code><span class="kw">def</span> markForDelayXRefRelativePathResolve(id: PyDb.ObjectId) -> None:
<span class="ds">Marks the input Xref definition object ID that helps to delay resolving its referenced file
path type to relative . This function should be used for unnamed host drawing, in which the
host drawing's file path is still not determined until it is saved, so relative type path
cannot be saved in Xref definitions with this function. These marked XRef definitions will
be resolved to relative path when the host drawing is saved.</span></code>
<code><span class="kw">def</span> menuCmd(cmd: str) -> int:</code>
<code><span class="kw">def</span> osnap(pt: PyGe.Point3d, mode: str) -> PyGe.Point3d:
<span class="ds">Finds a point by means of object snap. Applies the specified Object Snap modes to find the
closest point to a reference point. The APERTURE system variable determines the allowable
proximity of a selected point to an entity when using Object Snap. If acedOsnap() can find
a point, it returns RTNORM; otherwise, it returns an error code.</span></code>
<code><span class="kw">def</span> pSpace() -> None:
<span class="ds">When called in a layout, this function switches the editor to paper space. Returns
Acad::eOk if successful, or if the editor is currently in paper space. Returns
Acad::eInvalidInput if TILEMODE is set to 1, or if there is no current drawing.</span></code>
<code><span class="kw">def</span> postCommand(str: str) -> None:</code>
<code><span class="kw">def</span> postCommandPrompt() -> None:
<span class="ds">This function causes AutoCAD to repost the last command prompt message. This is intended to
be used from OLE applications that are invoked without going through the normal AutoCAD
user interface. In such a case this function should be called just prior to exiting from
the OLE application.</span></code>
<code><span class="kw">def</span> prompt(val: str) -> int:
<span class="ds">Displays the specified string on the command line of the AutoCAD graphics screen. If the
length of the string is greater than the prompt line length (typically no more than 80
characters), the characters may wrap around and be visible on the text screen. On some
platforms, however, they will be truncated. The acedPrompt() function returns RTNORM if
successful; otherwise, it returns an error code.</span></code>
<code><span class="kw">def</span> putSym(sym: str, resultBuffer: list) -> bool:
<span class="ds">Sets the value of an AutoLISP symbol. Warning This command can be used in the ARX program
environment only when AutoCAD sends the message kInvkSubrMsg to the application. To set the
value of the AutoLISP symbol to nil, make the following assignment: value->restype = RTNIL;
If sname is not the name of a current symbol, acedPutSym() creates a new AutoLISP symbol
with this name and assigns it the value.</span></code>
<code><span class="kw">def</span> redraw(id: PyDb.ObjectId, mode: int) -> int:
<span class="ds">Redraws either the graphics viewport or a single entity, according to the arguments. The
following table shows the acceptable values for mode and the effect that each has. (If ent
is not NULL but mode is 0, the call has no effect.) Modes for acedRedraw: Redraw mode
Action 1 Redraw entity 2 Undraw entity (blank it out) 3 Highlight entity 4 Unhighlight
entity If ent is NULL, acedRedraw() is identical to the AutoCAD REDRAW command. If ent is a
valid entity name, and mode is nonzero, acedRedraw() affects only the specified entity.
acedRedraw() calls must be made in matched pairs. Every call with a mode of 2 must be
followed at some point by a call with a mode of 1. Every call with a mode of 3 must be
followed at some point by a call with a mode of 4. Mismatched calls such as a call with a
mode of 3 followed by a call with a mode of 1 are not allowed. (This is a change from the
previous behaviour of this function that was necessary for display performance
optimization.) If acedRedraw() succeeds, it returns RTNORM; otherwise, it returns an error
code. When acedRedraw() fails, it sets the system variable ERRNO to a value that indicates
the reason for the failure.</span></code>
<code><span class="kw">def</span> regen() -> None:</code>
<code><span class="kw">def</span> reloadMenus(bIncrementalReloading: bool) -> None:
<span class="ds">Updates the User Interface in AutoCAD to reflect any changes made to the currently loaded
menus.</span></code>
<code><span class="kw">def</span> removeSupplementalCursorImage() -> bool:</code>
<code><span class="kw">def</span> restoreCurrentView(vid: PyDb.ObjectId) -> None:
<span class="ds">Restore a named view to the current active viewport. This function restores the view
parameters, layers state, and all associated properties to the current active viewport. The
fucntion is equivalent to the -view restore command. Returns Acad::eOk if it successfully
restores a named view into the current active viewport.</span></code>
<code><span class="kw">def</span> restorePreviousUCS() -> None:
<span class="ds">Sets the previous UCS to be the current UCS. This function operates on the document
currently displayed in the editor. Returns Acad::eOk if successful. Returns
Acad::eNotApplicable if there is no previous UCS to restore, or if there is no current
document.</span></code>
<code><span class="kw">def</span> restoreStatusBar() -> None:
<span class="ds">Restores AutoCAD's original status bar.</span></code>
<code><span class="kw">def</span> sendModelessOperationEnded(ctx: str) -> None:
<span class="ds">Informs AutoCAD when a modeless application has finished some significant operation
identified by strContext.</span></code>
<code><span class="kw">def</span> sendModelessOperationStart(ctx: str) -> None:
<span class="ds">Informs AutoCAD when a modeless application is starting some significant operation
identified by strContext.</span></code>
<code><span class="kw">def</span> setCfg(sym: str, val: str) -> None:
<span class="ds">Writes application data to the AppData section of the acad.cfg file.</span></code>
<code><span class="kw">def</span> setColorDialog(clr: int, bAllowMetaColor: bool, nCurLayerColor, int) -> tuple[bool, int]:
<span class="ds">This function starts the SetColor dialog within the AutoCAD editor. The value passed in via
nColor is used as the default color index in the dialog. Upon return nColor contains the
color index of the color selected by the user. If bAllowMetaColor is Adesk::kTrue, the
BYLAYER and BYBLOCK meta-colors are allowed in the dialog. nCurLayerColor is used as the
color index of the color to show for BYLAYER. If the SetColor dialog is invoked using this
function, only the color index tab is available. To enable the user to select additional
color types, invoke the SetColor dialog with the acedSetColorDialogTrueColor() function.
Returns Adesk::kTrue if the dialog was successfully terminated via the OK button, or
Adesk::kFalse if the dialog was canceled.</span></code>
<code><span class="kw">def</span> setColorDialogTrueColor(clr: PyDb.AcCmColor, bAllowMetaColor: bool, nCurLayerColor: PyDb.AcCmColor, tab: int) -> tuple[bool, PyDb.Color]:
<span class="ds">This function starts the Set Color dialog box within the AutoCAD editor. The value passed
in color is the default color in the dialog. This can affect which tab and controls are
active upon entering the dialog box. When the function returns, color contains the color
selected by the user or the original value if the dialog box was aborted. If
bAllowMetaColor is Adesk::kTrue, the BYLAYER and BYBLOCK metacolors are allowed in the
dialog. curLayerColor is the color to show for BYLAYER. The function returns Adesk::kTrue
if the dialog box was successfully terminated by the OK button; it returns Adesk::kFalse if
the dialog box was canceled.</span></code>
<code><span class="kw">def</span> setColorPrompt(prompt: str, bAllowMetaColor: bool) -> PyDb.Color:
<span class="ds">Prompts the user for a color on the command line. Returns true if successful; otherwise,
returns false.</span></code>
<code><span class="kw">def</span> setCurrentVPort(vp: PyDb.Viewport) -> None:
<span class="ds">This function sets the current viewport from the viewport index vpnumber. Viewport index
numbers are the numbers reported by the CVPORT system variable. SysVarWillChange and
SysVarChanged notification are generated by this function. Returns Acad::eOk if successful.
Returns Acad::eOutOfRange if vpnumber isn't valid for the current environment.</span></code>
<code><span class="kw">def</span> setCurrentView(vrec: PyDb.ViewTableRecord, vp: PyDb.Viewport) -> None:
<span class="ds">This function uses the information from the AcDbViewTableRecord pointed to by pVwRec to set
the view in the AcDbViewport pointed to by pVP (if pVP != NULL) or in the current viewport
(if pVP == NULL).</span></code>
<code><span class="kw">def</span> setEnv(sym: str, val: str) -> None:
<span class="ds">The acedSetEnv() function sets the value of an environment variable. It stores the data
only in the AutoCAD-specific FixedProfile/General section of the registry:
HKEY_CURRENT_USER Software Autodesk AutoCAD R25.0 <Install ID> FixedProfile General If this
function is called on a Windows system environment variable, that variable will be
overridden in the AutoCAD section of the registry and will remain overridden until the
associated registry entry is manually deleted.</span></code>
<code><span class="kw">def</span> setFieldUpdateEnabled(doc: PyAp.Document, enabled: bool) -> None:
<span class="ds">Gets the flag of field update enabled.</span></code>
<code><span class="kw">def</span> setFunHelp(functionName: str, helpfile: str, topic: str, iCmd: int) -> int:
<span class="ds">Defines a Help call that should be made if a transparent Help request is made during a
command line prompt for the function named pszFunctionName. This function registers Help
for functions that are called from the AutoCAD command line so that the appropriate Help
file and topic are called when help is requested at a user prompt. acedSetFunHelp() may be
used for ObjectARX commands, as well as ObjectARX and AutoLISP commands that start with C:.</span></code>
<code><span class="kw">def</span> setStatusBarProgressMeter(lable: str, nMinPos: int, nMaxPos: int) -> int:
<span class="ds">This displays an option label and a progress meter on the AutoCAD status bar. Pass NULL or
an empty string for the label if no label is desired. Returns 0 if it successfully creates
the label and progress meter; otherwise, returns -1.</span></code>
<code><span class="kw">def</span> setStatusBarProgressMeterPos(pos: int) -> int:
<span class="ds">Call this with a positive value within the range specified to set the current position of
the status bar. Pass a negative number to add an amount to the current position (relative).
Returns 0 if it successfully creates the label and progress meter; otherwise, returns -1.</span></code>
<code><span class="kw">def</span> setSupplementalCursorOffset(x: int, y: int) -> None:</code>
<code><span class="kw">def</span> setUndoMark(flag: bool) -> None:</code>
<code><span class="kw">def</span> setVar(name: str, value) -> bool:
<span class="ds">Sets the specified AutoCAD system variable. The val argument must point to a result buffer,
because the system variables consist of a variety of types. The result buffer must be
initialized and must contain a valid result type code and value that correspond to the type
and values allowed for the specified system variable. AutoCAD system variables that take
integer values are 16-bit short integers. The value supplied in the val->resval.rint field
of the result buffer must be between -32,768 and +32,767. Some AutoCAD commands inspect the
values of system variables before they prompt the user. If the application calls
acedSetVar() while such a command is in progress, the new value may not become current
until the command has completed its execution. This function is the complement of the
acedGetVar() function. If acedSetVar() succeeds, it returns RTNORM; otherwise, it returns
an error code. When acedSetVar() fails, it sets the system variable ERRNO to a value that
indicates the reason for the failure.</span></code>
<code><span class="kw">def</span> setXrefResolvedWithUpdateStatus(rec: PyDb.BlockTableRecord) -> None:
<span class="ds">This function forces the Xref Notification feature to treat the specified Xref as having
been resolved with an updated drawing, just as if it was reloaded through the user
interface. Returns Acad::eOk if successful; otherwise, eInvalidInput if pBTR was NULL or
invalid.</span></code>
<code><span class="kw">def</span> showHTMLModalWindow(hwnd: int, uriOfHtmlPage: str, persistSizeAndPosition: bool) -> bool:
<span class="ds">This function can be used to launch a modal dialog with the specified URI. The window hosts
a browser window which displays the html page.</span></code>
<code><span class="kw">def</span> showHTMLModelessWindow(hwnd: int, uriOfHtmlPage: str, persistSizeAndPosition: bool) -> int:
<span class="ds">This function can be used to launch a modeless dialog with the specified URI. The window
hosts a browser window which displays the html page.</span></code>
<code><span class="kw">def</span> skipXrefNotification(db: PyDb.Database, name: str) -> None:
<span class="ds">This function directs the Xref Notification feature to ignore the update of the Xref,
identified by its name, xrefName, for the specified host database, pHostDb. In effect, the
Xref is treated as if it had been reloaded as of the time this function is called. Returns
Acad::eOk if the xref notification will be skipped for the specified xref. Returns
Acad::eNotApplicable if the XREFNOTIFY system variable is 0 (indicating xref notification
is disabled). Returns Acad::eInvalidInput if the pHostDb parameter is NULL or xrefName is
the empty string. Returns Acad::eKeyNotFound if the xref cannot be found.</span></code>
<code><span class="kw">def</span> textBox(resultBuffer: list) -> tuple[PyGe.Point3d, PyGe.Point3d]:
<span class="ds">Finds the coordinates of a box that encloses a text entity. Assumes that the origin is
(0,0) and the rotation is 0 (or 270 if the text is vertical). If the text is located at a
different point or is rotated, your program must handle these values explicitly. If the
text is horizontal and is not rotated, p1 (the bottom-left corner) and p2 (the top-right
corner) describe the bounding box of the text. The coordinates are expressed in the ECS of
ent, with the origin (0,0) at the left endpoint of the baseline. (The origin is not the
bottom-left corner if the text contains letters with descenders, such as g and p.) If the
text is vertical or rotated, p1 and p2 still observe the left-to-right, bottom-to-top
order; the offsets are negative, if necessary. If the result-buffer list passed in ent
begins with a -1 (entity name) group, this group must name an existing text, attdef, or
attrib entity. No further groups need to be present, but if the list contains further
groups, these override the entity's actual attributes. If the result-buffer list doesn't
begin with a -1 group, it must begin with a 0 (entity type) group, and it must contain a
group that contains the string itself. This is a 1 (value) group for a text or attrib
entity, or a 2 (tag string) group for an attdef entity. Other values are assumed to be the
default values unless they are explicitly specified. The defaults are as follows: Style
(group 7)--Defaults to the current text style Size (group 40)--Defaults to the size of the
style if that is fixed; otherwise, defaults to the current default size of the style Width
factor (group 41)--Defaults to the default width of the style Obliquing angle (group
51)--Defaults to the default angle of the style If acedTextBox() succeeds, it returns
RTNORM; it returns RTERROR if ent does not correctly specify a text entity. If
acedTextBox() fails, it sets the system variable ERRNO to a value that indicates the reason
for the failure.</span></code>
<code><span class="kw">def</span> textPage() -> None:
<span class="ds">On single-screen AutoCAD installations, this function causes the display to switch from the
graphics screen to the text screen. This is identical to the acedTextScr() function. If
acedTextPage() succeeds, it returns RTNORM. Otherwise, it returns an error code.</span></code>
<code><span class="kw">def</span> textScr() -> None:
<span class="ds">On single-screen AutoCAD installations, causes the display to switch from the graphics
screen to the text screen. This is equivalent to the AutoCAD TEXTSCR command or to pressing
the flip screen function key (when the graphics screen is current). Its functionality is
also identical to that of the acedTextPage() function. The acedGraphScr() function is the
complement of acedTextScr(). If acedTextScr() succeeds, it returns RTNORM. Otherwise, it
returns an error code.</span></code>
<code><span class="kw">def</span> trans(pt: PyGe.Point3d, rbFrom: tuple, rbTo: tuple, disp: bool) -> PyGe.Point3d:
<span class="ds">Translates a point or a displacement from one coordinate system into another. The from and
to arguments can specify a coordinate system in any of the following ways: An integer code
(restype == RTSHORT) that specifies the WCS, current User Coordinate System (UCS), or
current Drawing Coordinate System (DCS) (of either the current viewport or paper space), as
described in the following table.An entity name (restype == RTENAME), as returned by one of
the entity name or selection set functions. This specifies the ECS of the named entity.For
planar entities, the ECS can differ from the WCS. If the ECS does not differ, conversion
between ECS and WCS is an identity operation. A 3D extrusion vector (restype == RT3DPOINT).
This is another method of specifying an entity's ECS.Extrusion vectors are always
represented in World coordinates; an extrusion vector of (0,0,1) specifies the WCS.
Coordinate system codes: 0 World (WCS) 1 User (current UCS) 2 Display:DCS of current
viewport when used with code 0 or 1DCS of current model space viewport when used with code
3 3 Paper space DCS (PSDCS; used only with code 2) Warning The paper space DCS (PSDCS) can
be transformed only to or from the model space DCS. Therefore, if the from argument equals
3, the to argument must equal 2, and conversely. If acedTrans() succeeds, it returns
RTNORM; otherwise, it returns an error code. When acedTrans() fails, it sets the system
variable ERRNO to a value that indicates the reason for the failure.</span></code>
<code><span class="kw">def</span> unloadPartialMenu(mnu: str) -> bool:
<span class="ds">Removes (unloads) a partial menu from the current main menu.</span></code>
<code><span class="kw">def</span> unmarkForDelayXRefRelativePathResolve(id: PyDb.ObjectId) -> None:
<span class="ds">Unmarks the input Xref definition object ID, which is marked in the function
acedMarkForDelayXRefRelativePathResolve(.)If this object ID is not marked before by the
function acedMarkForDelayXRefRelativePathResolve(), then this function will be a
no-operation.</span></code>
<code><span class="kw">def</span> update(vport: int, pt1: PyGe.Point2d, pt2: PyGe.Point2d) -> int:
<span class="ds">Refreshes a rectangular sub-area of the viewport. The corners must be specified in drawing
coordinates. As long as p1 and p2 are diagonally opposite each other, it does not matter
which two corners of the area are specified.</span></code>
<code><span class="kw">def</span> updateDisplay() -> None:
<span class="ds">This function causes AutoCAD to update its display screen. The update is essentially a
repaint of the AutoCAD graphics window with what AutoCAD's display engine has cached as the
window's image. AutoCAD manages its display area in the most efficient way by keeping track
of which portions of the screen are affected as you make various calls to AutoCAD. In
general the calls you make will not immediately be reflected in screen changes. AutoCAD
will conglomerate the calls and make them apparent at times that minimize disturbances to
the screen. When AutoCAD is not active or has no focus, it will not update its display at
all. If you're in a modeless dialog and adding or updating an entity, the display won't
show the changes when they occur. In such cases, you can use this function to force AutoCAD
to update its display.</span></code>
<code><span class="kw">def</span> updateDisplayPause(val: bool) -> None:
<span class="ds">This function allows an application to turn off display updates in order to hide automated
tasks from the user. All documents are affected by this call. This call should not be
enabled if any kind of drawing area input is expected from the user. The restrictions on
what can be done in this paused state are the same as they would be if the display was not
paused. Callers of this function should first save the return value from
acedIsUpdateDisplayPaused(), then restore that value when finished pausing the display.</span></code>
<code><span class="kw">def</span> usrBrk() -> bool:
<span class="ds">Checks whether the user has pressed [Esc] to interrupt execution of the current external
function. This function enables ARX applications that do long, complex operations to check
for a user interrupt. The interactive ARX library functions, such as acedEntSel() or those
in the user input (acedGetXxx()) group, check for [Esc] before they return to the ARX
application (returning a status of RTCAN if [Esc] was pressed). Because of this, ARX
applications don't need to call acedUsrBrk() unless they perform a lot of computation
between requests for user input. Your application should call this function at strategic
locations, such as at the top of a long evaluation loop. Do not use this function as a
substitute for checking the value returned by ARX library functions. If an application
ignores a user's cancellation request, it must call acedUsrBrk() to clear the request.
Otherwise, the [Esc] will still be outstanding and will cancel the next call to an
acedGetXxx() function or to the acedCommand(), acedCmd(), acedDragGen(), acedEntSel(),
acedNEntSelP(), acedNEntSel(), or acedSSGet() functions. If the user has pressed [Esc],
acedUsrBrk() returns 1; otherwise, it returns 0.</span></code>
<code><span class="kw">def</span> viewportIdFromNumber(val: int) -> PyDb.ObjectId:
<span class="ds">Returns the objectID that corresponds to the viewport number specified by nVpNum. This
number is the same as that reported by the CVPORT AutoCAD system variable. For example, the
Paper Space viewport is number 1. In tilemode the returned ID is obtained from a viewport
table record. In layout mode it is obtained from a viewport entity. Returns null if no
documents are open, or if the number does not correspond to a valid viewport.</span></code>
<code><span class="kw">def</span> vpLayer(id: PyDb.ObjectId, layerIds: list[PyDb.ObjectId], operation: PyDb.VpFreezeOps) -> None:
<span class="ds">This function modifies the viewport specified by vpId to freeze, thaw, or reset the layers
specified by the object IDs in layerIds. If operation is AcDb::kFreeze, the specified
layers will be frozen in the viewport. If operation is AcDb::kThaw, the specified layers
will be thawed in the viewport. If operation is AcDb::Reset, the specified layers whose
VPDFLT() method returns true will be frozen in the viewport and those whose VPDFLT() method
returns false will be thawed in the viewport. WarningThe viewport specified by vpId must be
closed when this function is called. operation may be one of the following: kFreeze, kThaw,
kReset. Returns Acad::eOk if successful. Returns Acad::eInvalidInput under any of the
following circumstances: if vpId is NULL or is not in the current drawingif the object
specified by vpId is not an instance of either AcDbViewport or a class derived from
AcDbViewportif operation is not valid</span></code>
<code><span class="kw">def</span> vportTableRecords2Vports() -> None:
<span class="ds">For the currenlty active drawing, this function copies the data from the
AcDbViewportTableRecords with the name '*ACTIVE' over into the corresponding displayed
viewports creating or removing display viewports if necessary. This function will result in
a regen in all viewports. Returns Acad::eOk if successful. Returns Acad::eNotApplicable
when called while tilemode is 0.</span></code>
<code><span class="kw">def</span> vports() -> list:
<span class="ds">Returns a pointer to a list of viewport descriptors for the current viewport configuration.
Warning To avoid a memory leak, before calling acedVports(), set result to null to ensure
that it does not point to allocated memory. If the AutoCAD TILEMODE system variable is set
to 1 (on), the returned list describes the viewport configuration created with the AutoCAD
VIEWPORTS command. The corners of the viewports are expressed in values between 0.0 and
1.0, with (0.0, 0.0) representing the lower-left corner of the display screen's graphics
area, and (1.0, 1.0) representing the upper-right corner. Each viewport descriptor is a
sublist consisting of the viewport identification number and the coordinates of the
viewport's lower-left and upper-right corners. If TILEMODE is 0 (off), the returned list
describes the viewport entities created with the MVIEW command. The viewport entity corners
are expressed in paper space coordinates. Viewport number 1 is always paper space when
TILEMODE is off. The current viewport's descriptor is always first in the list. If it
succeeds, acedVports() returns RTNORM; it returns RTERROR if it can't allocate the list.
Call acutRelRb() to deallocate memory for the contents of result.</span></code>
<code><span class="kw">def</span> vports2VportTableRecords() -> None:
<span class="ds">For the currently active drawing, this function copies the displayed viewport data over
into the corresponding AcDbViewportTableRecords (those with the name '*ACTIVE'), creating
or erasing '*ACTIVE' AcDbViewportTableRecords as necessary. Returns Acad::eOk if
successful. Returns Acad::eNotApplicable when called while tilemode is 0.</span></code>
<code><span class="kw">def</span> xrefAttach(path: str, name: str) -> None:</code>
<code><span class="kw">def</span> xrefAttach(path: str, name: str, btrid: PyDb.ObjectId, refid: PyDb.ObjectId, pt: PyGe.Point3d, sc: PyGe.Scale3d, rot: float, bQuiet: bool, pHostDb: PyDb.Database, passwd: str) -> None:</code>
<code><span class="kw">def</span> xrefAttach(*args) -> None:</code>
<code><span class="kw">def</span> xrefBind(XrefBlockname: str) -> None:</code>
<code><span class="kw">def</span> xrefBind(XrefBlockname: str, bInsertBind: bool, bQuiet: bool, pHostDb: PyDb.Database) -> None:</code>
<code><span class="kw">def</span> xrefBind(*args) -> None:</code>
<code><span class="kw">def</span> xrefCreateBlockname(XrefPathname: str) -> str:</code>
<code><span class="kw">def</span> xrefDetach(XrefBlockname: str) -> None:</code>
<code><span class="kw">def</span> xrefDetach(XrefBlockname: str, bQuiet: bool, pHostDb: PyDb.Database) -> None:</code>
<code><span class="kw">def</span> xrefDetach(*args) -> None:</code>
<code><span class="kw">def</span> xrefNotifyCheckFileChanged(id: PyDb.ObjectId) -> bool:</code>
<code><span class="kw">def</span> xrefOverlay(path: str, name: str) -> None:</code>
<code><span class="kw">def</span> xrefOverlay(path: str, name: str, btrid: PyDb.ObjectId, refid: PyDb.ObjectId, pt: PyGe.Point3d, sc: PyGe.Scale3d, rot: float, bQuiet: bool, pHostDb: PyDb.Database, passwd: str) -> None:</code>
<code><span class="kw">def</span> xrefOverlay(*args) -> None:</code>
<code><span class="kw">def</span> xrefReload(symbolIds: list[PyDb.ObjectId]) -> None:</code>
<code><span class="kw">def</span> xrefReload(symbolIds: list[PyDb.ObjectId], bQuiet: bool, pHostDb: PyDb.Database) -> None:</code>
<code><span class="kw">def</span> xrefReload(name: str) -> None:</code>
<code><span class="kw">def</span> xrefReload(name: str, bQuiet: bool, pHostDb: PyDb.Database) -> None:</code>
<code><span class="kw">def</span> xrefReload(*args) -> None:</code>
<code><span class="kw">def</span> xrefResolve(db: PyDb.Database, bQuiet: bool) -> None:</code>
<code><span class="kw">def</span> xrefUnload(XrefBlockname: str) -> None:</code>
<code><span class="kw">def</span> xrefUnload(XrefBlockname: str, bQuiet: bool, pHostDb: PyDb.Database) -> None:</code>
<code><span class="kw">def</span> xrefUnload(*args) -> None:</code>
<code><span class="kw">def</span> xrefXBind(symbolIds: list[PyDb.ObjectId]) -> None:</code>
<code><span class="kw">def</span> xrefXBind(symbolIds: list[PyDb.ObjectId], bQuiet: bool, pHostDb: PyDb.Database) -> None:</code>
<code><span class="kw">def</span> xrefXBind(*args) -> None:</code>
</details>
</div>
<div class="class" id="CursorType">
<details>
<summary>class CursorType <span class="tag">Class</span></summary>
<code>kNoSpecialCursor: ClassVar[Self]</code>
<code>kCrosshair: ClassVar[Self]</code>
<code>kRectCursor: ClassVar[Self]</code>
<code>kRubberBand: ClassVar[Self]</code>
<code>kNotRotated: ClassVar[Self]</code>
<code>kTargetBox: ClassVar[Self]</code>
<code>kRotatedCrosshair: ClassVar[Self]</code>
<code>kCrosshairNoRotate: ClassVar[Self]</code>
<code>kInvisible: ClassVar[Self]</code>
<code>kEntitySelect: ClassVar[Self]</code>
<code>kParallelogram: ClassVar[Self]</code>
<code>kEntitySelectNoPersp: ClassVar[Self]</code>
<code>kPkfirstOrGrips: ClassVar[Self]</code>
<code>kCrosshairDashed: ClassVar[Self]</code>
</details>
</div>
<div class="class" id="DragStatus">
<details>
<summary>class DragStatus <span class="tag">Class</span></summary>
<code>kModeless: ClassVar[Self]</code>
<code>kNoChange: ClassVar[Self]</code>
<code>kCancel: ClassVar[Self]</code>
<code>kOther: ClassVar[Self]</code>
<code>kNull: ClassVar[Self]</code>
<code>eNormal: ClassVar[Self]</code>
<code>eOk: ClassVar[Self]</code>
<code>kNormal: ClassVar[Self]</code>
<code>kKW1: ClassVar[Self]</code>
<code>kKW2: ClassVar[Self]</code>
<code>kKW3: ClassVar[Self]</code>
<code>kKW4: ClassVar[Self]</code>
<code>kKW5: ClassVar[Self]</code>
<code>kKW6: ClassVar[Self]</code>
<code>kKW7: ClassVar[Self]</code>
<code>kKW8: ClassVar[Self]</code>
<code>kKW9: ClassVar[Self]</code>
</details>
</div>
<div class="class" id="DragStyle">
<details>
<summary>class DragStyle <span class="tag">Class</span></summary>
<code><span class="kw">def</span> __init__(self, styleTypeForOriginal: PyEd.DragStyleType, styleTypeForDragged: PyEd.DragStyleType) -> None:</code>
<code><span class="kw">def</span> __reduce__(self) -> Any:</code>
<code><span class="kw">def</span> setStyleTypeForDragged(self, styleTypeForDragged: PyEd.DragStyleType) -> PyDb.ErrorStatus:</code>
<code><span class="kw">def</span> setStyleTypeForOriginal(self, styleTypeForOriginal: PyEd.DragStyleType) -> PyDb.ErrorStatus:</code>
<code><span class="kw">def</span> styleTypeForDragged(self) -> DragStyleType:</code>
<code><span class="kw">def</span> styleTypeForOriginal(self) -> DragStyleType:</code>
</details>
</div>
<div class="class" id="DragStyleType">
<details>
<summary>class DragStyleType <span class="tag">Class</span></summary>
<code>kNone: ClassVar[Self]</code>
<code>kHide: ClassVar[Self]</code>
<code>kTransparent25: ClassVar[Self]</code>
<code>kTransparent75: ClassVar[Self]</code>
<code>kDeletedEffect: ClassVar[Self]</code>
<code>kHighlight: ClassVar[Self]</code>
<code>kNotSet: ClassVar[Self]</code>
</details>
</div>
<div class="class" id="DrawJig">
<details>