Το Simple API

Εισαγωγή

Το QCAD Simple API είναι ένα μικρό σύνολο καθολικών συναρτήσεων σεναρίων που απλοποιούν συνηθισμένες εργασίες, όπως την προσθήκη οντοτήτων σε ένα σχέδιο, την αναζήτηση οντοτήτων και την τροποποίησή τους (μετακίνηση, κοπή, στρογγυλοποίηση, μετατόπιση, …). Έχει σχεδιαστεί κυρίως για χρήση στο Script Shell και για σύντομα διαδικαστικά σενάρια που εκτελούνται από αρχείο, αλλά μπορεί να χρησιμοποιηθεί από οποιοδήποτε σενάριο.

Το Simple API καλύπτει μόνο ένα μικρό μέρος του πλήρους API του QCAD. Επειδή είναι γραμμένο το ίδιο σε ECMAScript (JavaScript), αποτελεί επίσης ένα καλό σημείο εκκίνησης για να μάθετε πώς λειτουργεί το υποκείμενο API του QCAD. Ο πηγαίος κώδικας βρίσκεται στα αρχεία scripts/simple.js και scripts/simple_*.js του πηγαίου κώδικα του QCAD.

Χρήση του Simple API

Στο Script Shell (Διάφορα > Ανάπτυξη > Script Shell) και σε σενάρια που εκκινούνται με Διάφορα > Ανάπτυξη > Εκτέλεση σεναρίου, όλες οι συναρτήσεις του Simple API είναι άμεσα διαθέσιμες. Πληκτρολογήστε για παράδειγμα:

addLine(0,0, 100,100);

Στα δικά σας αρχεία σεναρίων, για παράδειγμα σε διαδραστικές ενέργειες σεναρίου ή σε εργαλεία γραμμής εντολών, συμπεριλάβετε πρώτα το αρχείο simple.js:

include("scripts/simple.js");

addLine(0,0, 100,100);

Όλες οι συναρτήσεις λειτουργούν στο σχέδιο που είναι ανοιχτό εκείνη τη στιγμή στο παράθυρο της εφαρμογής QCAD, εκτός αν χρησιμοποιηθεί μια συναλλαγή για να ανακατευθυνθούν σε άλλο έγγραφο (δείτε Συναλλαγές).

Όλα τα παραδείγματα αυτής της σελίδας μπορούν να επικολληθούν στο Script Shell ενός κενού σχεδίου. Κάθε παράδειγμα δημιουργεί τις οντότητες που χρειάζεται. Χρησιμοποιήστε Προβολή > Αυτόματη μεγέθυνση ή τη συνάρτηση autoZoom() για να δείτε το αποτέλεσμα.

Συμβάσεις

Συντεταγμένες

Οι θέσεις μπορούν να δοθούν με τρεις διαφορετικούς τρόπους:

• Ως δύο ξεχωριστοί αριθμοί: addLine(0,0, 100,100)
• Ως πίνακας δύο αριθμών: addLine([0,0], [100,100])
• Ως αντικείμενο διανύσματος: addLine(new RVector(0,0), new RVector(100,100))

Οι γωνίες δίνονται πάντα σε μοίρες, εκτός από τις παραμέτρους αρχής και τέλους των ελλείψεων, οι οποίες δίνονται σε ακτίνια.

Αναφορές οντοτήτων

Οι συναρτήσεις που εργάζονται με μια υπάρχουσα οντότητα δέχονται την οντότητα με διάφορες μορφές:

• Ένα ID οντότητας (αριθμός), για παράδειγμα 1234.
• Ένα αντικείμενο οντότητας όπως επιστρέφεται από τις συναρτήσεις δημιουργίας, για παράδειγμα η τιμή επιστροφής της addLine(...).
• Μια θέση στο σχέδιο ([x,y] ή RVector): χρησιμοποιείται η οντότητα που βρίσκεται πλησιέστερα στη δεδομένη θέση.
• Ένα σχήμα (για παράδειγμα new RLine(0,0, 100,0)): η λειτουργία εφαρμόζεται μόνο στο σχήμα, το σχέδιο δεν αλλάζει.

var l = addLine(0,0, 100,0);
move(l, [0,10]);              // μέσω αντικειμένου οντότητας
move(l.getId(), [0,10]);      // μέσω ID οντότητας
move([50,20], [0,10]);        // μέσω θέσης: η οντότητα πλησιέστερα στο 50,20

Θέσεις κλικ

Ορισμένες λειτουργίες εξαρτώνται από το σημείο όπου γίνεται κλικ σε μια οντότητα όταν χρησιμοποιείται διαδραστικά το αντίστοιχο εργαλείο. Η κοπή διατηρεί το τμήμα της οντότητας στη θέση του κλικ, η στρογγυλοποίηση και η λοξότμηση επεξεργάζονται τα άκρα των οντοτήτων που βρίσκονται πλησιέστερα στις θέσεις κλικ και η μετατόπιση δημιουργεί παράλληλες στην πλευρά της θέσης κλικ.

Στο Simple API, κάθε αναφορά οντότητας μπορεί να ακολουθείται από μια θέση κλικ. Αν μια οντότητα αναφέρεται μέσω θέσης, η θέση αυτή χρησιμεύει και ως θέση κλικ. Αν δεν δοθεί θέση κλικ, χρησιμοποιείται το μέσο της οντότητας:

var line = addLine(0,0, 100,0);
var limit = addLine(70,-20, 70,20);

// κοπή της line στο limit, διατηρείται το τμήμα της γραμμής στο 10,0:
trim(line, [10,0], limit);

Τιμές επιστροφής

• Οι συναρτήσεις δημιουργίας επιστρέφουν την οντότητα που προστέθηκε. Η οντότητα μπορεί να δοθεί σε άλλες συναρτήσεις ή να χρησιμοποιηθεί για την ανάκτηση πληροφοριών (για παράδειγμα getId(), getLength() ή getStartPoint()).
• Οι μετασχηματισμοί (move, rotate, scale, mirror, lengthen, reverse) επιστρέφουν την τροποποιημένη οντότητα.
• Οι υπόλοιπες συναρτήσεις τροποποίησης (trim, round, bevel, offset, breakOut, autoTrim, divide, explode, stretch) επιστρέφουν τη συναλλαγή που εφαρμόστηκε στο σχέδιο ή undefined αν η λειτουργία απέτυχε.
• Αν δοθούν σχήματα αντί για οντότητες, οι μετασχηματισμοί τροποποιούν τα δεδομένα σχήματα και όλες οι άλλες συναρτήσεις επιστρέφουν τα σχήματα που προκύπτουν ως πίνακα.

Οι λειτουργίες που αποτυγχάνουν δεν προκαλούν σφάλμα. Αντίθετα, εμφανίζεται μια προειδοποίηση στο Script Shell, για παράδειγμα «Η οντότητα δεν μπορεί να κοπεί.».

Δημιουργία οντοτήτων

addPoint

addPoint(x, y)
addPoint([x, y])

Προσθέτει μια οντότητα σημείου στη δεδομένη θέση.

for (var i=0; i<10; i++) {
    addPoint(i*10, 0);
}

addLine

addLine(x1, y1, x2, y2)
addLine([x1, y1], [x2, y2])

Προσθέτει μια γραμμή από το σημείο αρχής έως το τελικό σημείο.

// ένα τρίγωνο:
addLine(0,0, 100,0);
addLine(100,0, 50,80);
addLine(50,80, 0,0);

addXLine

addXLine(x, y, dx, dy)
addXLine([x, y], [dx, dy])

Προσθέτει μια άπειρη γραμμή (γραμμή κατασκευής) που διέρχεται από το βασικό σημείο x,y με κατεύθυνση dx,dy. Η κατεύθυνση δίνεται σχετικά με το βασικό σημείο.

// οριζόντια γραμμή κατασκευής και γραμμή κατασκευής 45 μοιρών μέσω του 0,0:
addXLine(0,0, 1,0);
addXLine([0,0], [1,1]);

addArc

addArc(cx, cy, radius, startAngle, endAngle)
addArc(cx, cy, radius, startAngle, endAngle, reversed)
addArc([cx, cy], radius, startAngle, endAngle, reversed)

Προσθέτει ένα τόξο με το δεδομένο κέντρο, ακτίνα, γωνία αρχής και γωνία τέλους. Οι γωνίες δίνονται σε μοίρες. Τα τόξα εκτείνονται αριστερόστροφα από τη γωνία αρχής έως τη γωνία τέλους, εκτός αν το reversed είναι true (προαιρετικό, η προεπιλογή είναι false).

// τόξο ενός τεταρτημορίου από 0 έως 90 μοίρες:
addArc(0,0, 50, 0, 90);

// δεξιόστροφο τόξο από 0 έως 90 μοίρες (τα άλλα τρία τεταρτημόρια):
addArc([0,0], 40, 0, 90, true);

addCircle

addCircle(cx, cy, radius)
addCircle([cx, cy], radius)

Προσθέτει έναν κύκλο με το δεδομένο κέντρο και ακτίνα.

// ομόκεντροι κύκλοι:
for (var r=10; r<=50; r+=10) {
    addCircle(0,0, r);
}

addEllipse

addEllipse(cx, cy, mx, my, ratio, startParam, endParam, reversed)
addEllipse([cx, cy], [mx, my], ratio, startParam, endParam, reversed)

Προσθέτει μια έλλειψη ή ένα ελλειπτικό τόξο. Το mx,my είναι το τελικό σημείο του μεγάλου άξονα, σχετικά με το κέντρο. Το ratio είναι ο λόγος μεταξύ του μικρού και του μεγάλου άξονα. Τα startParam και endParam είναι οι παράμετροι της έλλειψης σε ακτίνια όπου η έλλειψη αρχίζει και τελειώνει. Χρησιμοποιήστε 0 και 2*Math.PI για πλήρη έλλειψη.

// πλήρης έλλειψη με μεγάλη ακτίνα 50 και μικρή ακτίνα 25:
addEllipse(0,0, 50,0, 0.5, 0, 2*Math.PI, false);

// πάνω μισό μιας περιστραμμένης έλλειψης:
addEllipse([0,0], [30,30], 0.3, 0, Math.PI, false);

addPolyline

addPolyline(points, closed, relative)

Προσθέτει μια πολυγραμμή που διέρχεται από τις δεδομένες κορυφές. Το points είναι ένας πίνακας κορυφών, καθεμία από τις οποίες δίνεται ως [x, y], [x, y, bulge] ή [x, y, bulge, relative]. Αντί για x, y, μπορεί να χρησιμοποιηθεί ένα RVector.

• Το bulge (εξόγκωση) ορίζει το σχήμα του τμήματος που αρχίζει σε αυτή την κορυφή: 0 (προεπιλογή) για ευθύγραμμο τμήμα, 1 για ημικύκλιο αριστερόστροφα, -1 για ημικύκλιο δεξιόστροφα. Άλλες τιμές δημιουργούν ενδιάμεσα τμήματα τόξου (η εξόγκωση είναι η εφαπτομένη του ενός τετάρτου της γωνίας του τόξου).
• relative: true αν οι συντεταγμένες αυτής της κορυφής είναι σχετικές με την προηγούμενη κορυφή.
• closed: true για κλείσιμο της πολυγραμμής (η προεπιλογή είναι false).
• relative: true για να θεωρούνται οι συντεταγμένες όλων των κορυφών σχετικές με την προηγούμενη κορυφή (η προεπιλογή είναι false).

// κλειστό ορθογώνιο:
addPolyline([[0,0], [100,0], [100,50], [0,50]], true);

// σχήμα οβάλ εγκοπής με δύο ημικύκλια:
addPolyline([[0,60], [80,60,1], [80,80], [0,80,1]], true);

// τεθλασμένη γραμμή ζιγκ-ζαγκ με σχετικές συντεταγμένες:
addPolyline([[0,100], [10,10], [10,-10], [10,10], [10,-10]], false, true);

addSpline

addSpline(fitPoints, closed)

Προσθέτει μια spline που διέρχεται από τα δεδομένα σημεία προσαρμογής. Το fitPoints είναι ένας πίνακας από πίνακες [x, y] ή αντικείμενα RVector. Αν το closed είναι true, η spline είναι κλειστή (περιοδική).

// ανοιχτή spline:
addSpline([[0,0], [30,40], [60,0], [90,40]], false);

// κλειστή spline:
addSpline([[0,60], [40,80], [80,60], [40,100]], true);

Το σεμινάριο Εκτέλεση σεναρίων από αρχείο δείχνει ένα ακόμη παράδειγμα που σχεδιάζει μια καμπύλη Lissajous ως spline.

addSimpleText

addSimpleText(text, x, y)
addSimpleText(text, x, y, height, angle, font, vAlign, hAlign, bold, italic)
addSimpleText(text, [x, y], height, angle, font, vAlign, hAlign, bold, italic)

Προσθέτει ένα κείμενο μίας γραμμής στη δεδομένη θέση. Όλα τα ορίσματα μετά τη θέση είναι προαιρετικά:

• height: ύψος κειμένου (προεπιλογή 1)
• angle: γωνία κειμένου σε μοίρες (προεπιλογή 0)
• font: όνομα γραμματοσειράς (προεπιλογή "Standard")
• vAlign: κατακόρυφη στοίχιση: RS.VAlignTop (προεπιλογή), RS.VAlignMiddle, RS.VAlignBase ή RS.VAlignBottom
• hAlign: οριζόντια στοίχιση: RS.HAlignLeft (προεπιλογή), RS.HAlignCenter ή RS.HAlignRight
• bold, italic: true για έντονο ή πλάγιο κείμενο (μόνο γραμματοσειρές TrueType)

addSimpleText("Hello World", 0,0);
addSimpleText("Title", [0,20], 10);
addSimpleText("Centered", [50,-20], 5, 0, "Standard", RS.VAlignMiddle, RS.HAlignCenter);
addSimpleText("Rotated", 100,0, 5, 45);

addSolid

addSolid(x1, y1, x2, y2, x3, y3, x4, y4)
addSolid([x1, y1], [x2, y2], [x3, y3], [x4, y4])

Προσθέτει μια περιοχή στερεού γεμίσματος με τρεις ή τέσσερις γωνίες. Σημειώστε ότι οι γωνίες ενός τετράπλευρου στερεού γεμίσματος δίνονται σε σειρά ζιγκ-ζαγκ: πρώτη γωνία, δεύτερη γωνία, έπειτα η γωνία απέναντι από τη δεύτερη γωνία και η γωνία απέναντι από την πρώτη γωνία. Για να δημιουργήσετε ένα τρίγωνο, δώστε την τρίτη γωνία δύο φορές.

// γεμάτο τετράγωνο:
addSolid(0,0, 50,0, 0,50, 50,50);

// γεμάτο τρίγωνο:
addSolid([60,0], [110,0], [85,50], [85,50]);

Προσθήκη σχημάτων, οντοτήτων και αντικειμένων

Οι παρακάτω συναρτήσεις προσθέτουν στο σχέδιο αντικείμενα που δημιουργήθηκαν με το πλήρες API του QCAD. Είναι χρήσιμες όταν οι εξειδικευμένες συναρτήσεις δημιουργίας παραπάνω δεν καλύπτουν μια συγκεκριμένη περίπτωση.

addShape

addShape(shape)
addShape(shape, color, linetype, lineweight)

Προσθέτει το δεδομένο σχήμα (RLine, RArc, RCircle, REllipse, RPolyline, RSpline, RPoint, …) ως νέα οντότητα στο τρέχον στρώμα. Προαιρετικά, μπορούν να δοθούν χρώμα (RColor), τύπος γραμμής (όνομα ή ID) και πάχος γραμμής (για παράδειγμα RLineweight.Weight050). Από προεπιλογή, χρησιμοποιούνται το τρέχον χρώμα, ο τύπος γραμμής ByLayer και το πάχος γραμμής ByLayer.

addShape(new RLine(new RVector(0,0), new RVector(100,0)));
addShape(new RCircle(new RVector(50,0), 20), new RColor("red"));
addShape(new RLine(new RVector(0,-20), new RVector(100,-20)), new RColor("blue"), "DASHED", RLineweight.Weight050);

addShapes

addShapes(shapes)

Προσθέτει όλα τα σχήματα του δεδομένου πίνακα ως νέες οντότητες.

var shapes = [];
for (var i=0; i<5; i++) {
    shapes.push(new RCircle(new RVector(i*20, 0), 8));
}
addShapes(shapes);

addEntity

addEntity(entity)
addEntity(entity, color, linetype, lineweight)

Προσθέτει τη δεδομένη οντότητα (REntity) στο σχέδιο. Αν δεν δοθεί χρώμα, χρησιμοποιείται το τρέχον χρώμα.

var doc = getDocument();
var data = new RLineData(new RVector(0,0), new RVector(100,50));
var entity = new RLineEntity(doc, data);
addEntity(entity);

addObject

addObject(object)

Προσθέτει οποιοδήποτε αντικείμενο (οντότητα, στρώμα, μπλοκ, …) στο σχέδιο και επιστρέφει το αντικείμενο που προστέθηκε.

// προσθήκη ενός μπλοκ με όνομα "Marker" που περιέχει έναν σταυρό:
var doc = getDocument();
var block = addObject(new RBlock(doc, "Marker", new RVector(0,0)));

var l1 = new RLineEntity(doc, new RLineData(new RVector(-5,0), new RVector(5,0)));
l1.setBlockId(block.getId());
addEntity(l1);
var l2 = new RLineEntity(doc, new RLineData(new RVector(0,-5), new RVector(0,5)));
l2.setBlockId(block.getId());
addEntity(l2);

// εισαγωγή του μπλοκ δύο φορές:
addEntity(new RBlockReferenceEntity(doc, new RBlockReferenceData(block.getId(), new RVector(0,0), new RVector(1,1), 0.0)));
addEntity(new RBlockReferenceEntity(doc, new RBlockReferenceData(block.getId(), new RVector(50,0), new RVector(2,2), 0.0)));

deleteObject

deleteObject(object)

Διαγράφει το δεδομένο αντικείμενο από το σχέδιο. Για τη διαγραφή οντοτήτων, η συνάρτηση deleteEntity είναι συνήθως πιο βολική.

var line = addLine(0,0, 100,0);
deleteObject(line);

Στρώματα και χαρακτηριστικά

addLayer

addLayer(name)
addLayer(name, color, linetype, lineweight)

Προσθέτει ένα νέο στρώμα με το δεδομένο όνομα. Προαιρετικά, μπορούν να δοθούν το όνομα χρώματος (προεπιλογή "white", που εμφανίζεται μαύρο σε λευκό φόντο), το όνομα τύπου γραμμής (προεπιλογή "CONTINUOUS") και το πάχος γραμμής (προεπιλογή RLineweight.Weight000). Επιστρέφει το νέο στρώμα ή undefined αν υπάρχει ήδη στρώμα με το δεδομένο όνομα.

addLayer("Construction", "gray", "DASHED");
addLayer("Contour", "blue", "CONTINUOUS", RLineweight.Weight050);

hasLayer

hasLayer(name)

Επιστρέφει true αν υπάρχει στο σχέδιο στρώμα με το δεδομένο όνομα.

if (!hasLayer("Holes")) {
    addLayer("Holes", "red");
}

setCurrentLayer

setCurrentLayer(name)

Ορίζει το τρέχον στρώμα. Όλες οι οντότητες που προστίθενται στη συνέχεια τοποθετούνται σε αυτό το στρώμα.

addLayer("Holes", "red");
setCurrentLayer("Holes");
addCircle(0,0, 5);
addCircle(50,0, 5);
setCurrentLayer("0");

setCurrentColor

setCurrentColor(color)
setCurrentColor(r, g, b)

Ορίζει το χρώμα για τις οντότητες που προστίθενται στη συνέχεια. Το χρώμα μπορεί να δοθεί ως αντικείμενο RColor ή ως τιμές κόκκινου, πράσινου, μπλε (0-255). Χρησιμοποιήστε new RColor(RColor.ByLayer) για να επαναφέρετε το χρώμα σε «Ανά στρώμα».

setCurrentColor(255, 0, 0);
addCircle(0,0, 10);
setCurrentColor(new RColor("blue"));
addCircle(30,0, 10);
setCurrentColor(new RColor(RColor.ByLayer));
addCircle(60,0, 10);

Αναζήτηση οντοτήτων

getEntity

getEntity(id)
getEntity(entity)
getEntity(x, y)
getEntity([x, y])

Επιστρέφει την οντότητα για τη δεδομένη αναφορά οντότητας, δηλαδή την οντότητα με το δεδομένο ID, την τρέχουσα κατάσταση της δεδομένης οντότητας ή την οντότητα που βρίσκεται πλησιέστερα στη δεδομένη θέση. Επιστρέφει undefined αν δεν βρεθεί οντότητα.

var circle = addCircle(0,0, 20);
move(circle, [10,0]);

// η circle περιέχει ακόμη το παλιό κέντρο, η getEntity επιστρέφει την τρέχουσα κατάσταση:
getEntity(circle).getCenter();     // επιστρέφει 10,0

// οντότητα πλησιέστερα στο 30,0:
getEntity(30,0).getRadius();       // επιστρέφει 20

getShape

getShape(id)
getShape(entity)
getShape(x, y)
getShape([x, y])

Επιστρέφει τη γεωμετρία της δεδομένης οντότητας ως σχήμα (RLine για γραμμή, RArc για τόξο, RPolyline για πολυγραμμή, …). Τα σχήματα μπορούν να χρησιμοποιηθούν για γεωμετρικούς υπολογισμούς χωρίς να αλλάζει το σχέδιο.

addPolyline([[0,0], [100,0], [100,50]], false);

var pl = getShape(50,0);
pl.getLength();                    // επιστρέφει 150

getClosestEntity

getClosestEntity(x, y)
getClosestEntity([x, y], range)

Επιστρέφει την οντότητα που βρίσκεται πλησιέστερα στη δεδομένη θέση. Αν δοθεί το range, λαμβάνονται υπόψη μόνο οντότητες εντός αυτής της απόστασης από τη θέση. Επιστρέφει undefined αν δεν βρεθεί οντότητα.

addLine(0,0, 100,0);
addLine(0,50, 100,50);

getClosestEntity(50,10).getStartPoint();     // επιστρέφει 0,0
getClosestEntity([50,25], 5);               // επιστρέφει undefined

getEntityShape

getEntityShape(entity, position)

Επιστρέφει το σχήμα του δεδομένου αντικειμένου οντότητας. Για σύνθετες οντότητες που αποτελούνται από πολλά σχήματα (αναφορές μπλοκ, διαγραμμίσεις, διαστάσεις, κείμενα), επιστρέφεται το σχήμα που βρίσκεται πλησιέστερα στη δεδομένη θέση. Η θέση είναι προαιρετική.

// μια αναφορά μπλοκ ενός μπλοκ με ένα ορθογώνιο:
var doc = getDocument();
var block = addObject(new RBlock(doc, "Box", new RVector(0,0)));
var pl = new RPolylineEntity(doc, new RPolylineData());
pl.setShape(new RPolyline([new RVector(0,0), new RVector(40,0), new RVector(40,20), new RVector(0,20)], true));
pl.setBlockId(block.getId());
addEntity(pl);
var ref = addEntity(new RBlockReferenceEntity(doc, new RBlockReferenceData(block.getId(), new RVector(0,0), new RVector(1,1), 0.0)));

// σχήμα της αναφοράς μπλοκ κοντά στο 40,10 (το ορθογώνιο):
var s = getEntityShape(getEntity(ref), new RVector(41,10));
s.getLength();                     // επιστρέφει 120

getIntersectionPoints

getIntersectionPoints(entity1, entity2)
getIntersectionPoints(entity1, entity2, limited)

Επιστρέφει έναν πίνακα με τα σημεία τομής των δύο δεδομένων οντοτήτων ή σχημάτων. Οι οντότητες μπορούν να δοθούν ως αντικείμενα οντοτήτων, ID οντοτήτων ή σχήματα. Αν το limited είναι false, οι οντότητες αντιμετωπίζονται σαν να ήταν άπειρες (οι γραμμές προεκτείνονται, τα τόξα ως πλήρεις κύκλοι). Η προεπιλογή είναι true.

var line = addLine(-50,0, 50,0);
var circle = addCircle(0,0, 30);
var ips = getIntersectionPoints(line, circle);

// σήμανση των σημείων τομής με μικρούς κύκλους:
for (var i=0; i<ips.length; i++) {
    addCircle(ips[i], 2);
}

isPosition και toVector

isPosition(value)
toVector(value)

Η isPosition επιστρέφει true αν η δεδομένη τιμή είναι θέση (RVector ή πίνακας δύο ή τριών αριθμών). Η toVector μετατρέπει μια θέση που δίνεται ως πίνακας σε RVector. Αυτές οι συναρτήσεις είναι χρήσιμες όταν γράφετε δικές σας συναρτήσεις που δέχονται θέσεις με τον ίδιο τρόπο όπως το Simple API.

function addCross(pos, size) {
    var p = toVector(pos);
    addLine(p.x-size, p.y, p.x+size, p.y);
    addLine(p.x, p.y-size, p.x, p.y+size);
}

addCross([0,0], 5);
addCross(new RVector(20,0), 5);
isPosition([1,2]);                 // επιστρέφει true
isPosition("abc");                 // επιστρέφει false

Τροποποίηση οντοτήτων

Μετασχηματισμοί

move

move(entity, dx, dy)
move(entity, [dx, dy])

Μετακινεί τη δεδομένη οντότητα κατά τη δεδομένη μετατόπιση.

var c = addCircle(0,0, 10);
move(c, 50,0);

rotate

rotate(entity, angle)
rotate(entity, angle, cx, cy)
rotate(entity, angle, [cx, cy])

Περιστρέφει τη δεδομένη οντότητα κατά τη δεδομένη γωνία σε μοίρες γύρω από το δεδομένο κέντρο. Αν δεν δοθεί κέντρο, η οντότητα περιστρέφεται γύρω από την αρχή των αξόνων 0,0.

// μια βεντάλια από γραμμές, περιστραμμένες γύρω από το 0,0:
for (var a=0; a<360; a+=30) {
    var l = addLine(10,0, 50,0);
    rotate(l, a);
}

// περιστροφή ενός τετραγώνου γύρω από το κέντρο του:
var sq = addPolyline([[100,0], [120,0], [120,20], [100,20]], true);
rotate(sq, 45, [110,10]);

scale

scale(entity, factor)
scale(entity, factor, cx, cy)
scale(entity, factor, [cx, cy])
scale(entity, [sx, sy], [cx, cy])

Κλιμακώνει τη δεδομένη οντότητα κατά τον δεδομένο συντελεστή. Το σημείο εστίασης (το σημείο που παραμένει στη θέση του) είναι από προεπιλογή η αρχή των αξόνων 0,0. Διαφορετικοί συντελεστές για X και Y μπορούν να δοθούν ως πίνακας [sx, sy]. Σημειώστε ότι ορισμένες οντότητες, όπως οι κύκλοι και τα τόξα, δεν μπορούν να κλιμακωθούν με διαφορετικούς συντελεστές σε X και Y.

var sq = addPolyline([[0,0], [10,0], [10,10], [0,10]], true);
scale(sq, 3);

var pl = addPolyline([[50,0], [60,0], [60,10], [50,10]], true);
scale(pl, [2,1], [50,0]);

mirror

mirror(entity, x1, y1, x2, y2)
mirror(entity, [x1, y1], [x2, y2])
mirror(entity, new RLine(...))

Κατοπτρίζει τη δεδομένη οντότητα ως προς τον άξονα που ορίζεται από δύο σημεία.

var pl = addPolyline([[10,0], [40,0], [40,30]], false);
// κατοπτρισμός ως προς τον άξονα Y:
mirror(pl, 0,0, 0,100);

Για να διατηρήσετε το πρωτότυπο και να δημιουργήσετε ένα κατοπτρισμένο αντίγραφο, προσθέστε πρώτα ένα αντίγραφο της οντότητας:

var arc = addArc(20,0, 10, 0, 180);
var copy = addShape(getShape(arc));
mirror(copy, [0,-10], [0,10]);

Κοπή και επιμήκυνση

trim

trim(trimEntity, limitingEntity)
trim(trimEntity, trimPos, limitingEntity, limitingPos)
trim(trimEntity, trimPos, limitingEntity, limitingPos, trimBoth)
trim(trimPos, limitingPos)

Κόβει την οντότητα trimEntity στην περιοριστική οντότητα limitingEntity. Διατηρείται το τμήμα της οντότητας που κόβεται στη θέση κλικ trimPos. Αν οι δύο οντότητες δεν τέμνονται, η οντότητα επεκτείνεται έως την περιοριστική οντότητα. Αν υπάρχουν πολλά σημεία τομής, χρησιμοποιείται εκείνο που βρίσκεται πλησιέστερα στη θέση κλικ limitingPos. Αν το trimBoth είναι true, κόβονται και οι δύο οντότητες η μία στην άλλη.

var line = addLine(0,0, 100,0);
var limit = addLine(70,-20, 70,20);

// διατήρηση του αριστερού τμήματος, η γραμμή τελειώνει τώρα στο 70,0:
trim(line, [10,0], limit);

// επέκταση μιας γραμμής έως έναν κύκλο:
var line = addLine(0,0, 50,0);
var circle = addCircle(100,0, 20);

// επέκταση έως το σημείο τομής με τον κύκλο που βρίσκεται πλησιέστερα στο 80,0:
trim(line, [25,0], circle, [80,0]);      // η γραμμή τελειώνει τώρα στο 80,0

trimBoth

trimBoth(entity1, entity2)
trimBoth(entity1, pos1, entity2, pos2)
trimBoth(pos1, pos2)

Κόβει ή επεκτείνει και τις δύο οντότητες έως το σημείο τομής τους. Πρόκειται για συντόμευση της trim με το trimBoth ορισμένο σε true.

// δύο γραμμές που δεν εφάπτονται επεκτείνονται ώστε να σχηματίσουν γωνία στο 100,0:
var a = addLine(0,0, 80,0);
var b = addLine(100,20, 100,100);
trimBoth(a, b);

lengthen

lengthen(entity, amount)
lengthen(entity, start, amount)
lengthen(entity, pos, amount)
lengthen(pos, amount)

Επιμηκύνει τη δεδομένη οντότητα κατά το δεδομένο μήκος. Αρνητικές τιμές βραχύνουν την οντότητα. Από προεπιλογή, η οντότητα επιμηκύνεται στο τελικό της σημείο. Δώστε true για το start ώστε να επιμηκυνθεί αντί αυτού στο σημείο αρχής της, ή δώστε μια θέση κοντά στο άκρο που πρέπει να επιμηκυνθεί.

var line = addLine(0,0, 100,0);
lengthen(line, 20);              // η γραμμή τελειώνει τώρα στο 120,0
lengthen(line, true, -10);       // η γραμμή αρχίζει τώρα στο 10,0

var arc = addArc(0,50, 30, 0, 90);
lengthen(arc, [30,50], 10);      // επιμήκυνση του τόξου στο σημείο αρχής του

breakOut

breakOut(entity, pos)
breakOut(entity, pos, removeSegment)
breakOut(pos)

Διαχωρίζει το τμήμα της δεδομένης οντότητας στη δεδομένη θέση. Το τμήμα τελειώνει στα πλησιέστερα σημεία τομής με άλλες οντότητες σε κάθε πλευρά της θέσης. Αν δεν υπάρχει σημείο τομής στη μία πλευρά, το τμήμα εκτείνεται έως το άκρο της οντότητας. Αν το removeSegment είναι true (προεπιλογή), το τμήμα διαγράφεται. Διαφορετικά, διατηρείται ως ξεχωριστή οντότητα.

var line = addLine(0,0, 100,0);
addLine(30,-10, 30,10);
addLine(70,-10, 70,10);

// αφαίρεση του τμήματος της γραμμής μεταξύ 30,0 και 70,0:
breakOut(line, [50,0]);

autoTrim

autoTrim(entity, pos)
autoTrim(pos)

Το αντίθετο της breakOut: διατηρεί μόνο το τμήμα της δεδομένης οντότητας στη δεδομένη θέση και αφαιρεί το υπόλοιπο. Το τμήμα τελειώνει στα πλησιέστερα σημεία τομής με άλλες οντότητες σε κάθε πλευρά της θέσης.

var line = addLine(0,0, 100,0);
addLine(30,-10, 30,10);
addLine(70,-10, 70,10);

// διατήρηση μόνο του τμήματος μεταξύ 30,0 και 70,0:
autoTrim(line, [50,0]);

divide

divide(entity, pos)
divide(entity, pos1, pos2)
divide(pos)

Διαιρεί τη δεδομένη οντότητα στη δεδομένη θέση. Μια ανοιχτή οντότητα (γραμμή, τόξο, ανοιχτή πολυγραμμή, …) διαιρείται σε δύο μέρη σε μία θέση ή σε τρία μέρη σε δύο θέσεις. Οι κλειστές οντότητες (κύκλοι, πλήρεις ελλείψεις, κλειστές πολυγραμμές) απαιτούν δύο θέσεις και διαιρούνται σε δύο μέρη.

var line = addLine(0,0, 100,0);
divide(line, [40,0]);            // δύο γραμμές: 0..40 και 40..100

var circle = addCircle(0,50, 20);
divide(circle, [20,50], [-20,50]);   // δύο ημικύκλια

Γωνίες

round

round(entity1, entity2, radius)
round(entity1, pos1, entity2, pos2, radius)
round(entity1, pos1, entity2, pos2, radius, trim)
round(pos1, pos2, radius)

Στρογγυλοποιεί τη γωνία μεταξύ δύο οντοτήτων με ένα τόξο της δεδομένης ακτίνας (fillet). Οι θέσεις κλικ υποδεικνύουν ποια άκρα των οντοτήτων στρογγυλοποιούνται. Αν το trim είναι true (προεπιλογή), και οι δύο οντότητες κόβονται στο τόξο στρογγυλοποίησης.

// ένα ορθογώνιο με στρογγυλεμένες γωνίες:
var l1 = addLine(0,0, 100,0);
var l2 = addLine(100,0, 100,50);
var l3 = addLine(100,50, 0,50);
var l4 = addLine(0,50, 0,0);

round(l1, l2, 10);
round(l2, l3, 10);
round(l3, l4, 10);
round(l4, l1, 10);

Μπορούν επίσης να στρογγυλοποιηθούν οι γωνίες μιας πολυγραμμής, δίνοντας την ίδια πολυγραμμή δύο φορές με μια θέση κλικ σε καθένα από τα δύο τμήματα:

var pl = addPolyline([[0,0], [100,0], [100,50]], false);
round(pl, [50,0], pl, [100,25], 10);

bevel και chamfer

bevel(entity1, entity2, distance)
bevel(entity1, entity2, distance1, distance2)
bevel(entity1, pos1, entity2, pos2, distance1, distance2)
bevel(entity1, pos1, entity2, pos2, distance1, distance2, trim)
bevel(pos1, pos2, distance)

Λοξοτμεί τη γωνία μεταξύ δύο οντοτήτων με μια ευθεία γραμμή (φάλτσο). Το distance1 είναι η απόσταση της γραμμής λοξότμησης από τη γωνία κατά μήκος της πρώτης οντότητας, το distance2 κατά μήκος της δεύτερης οντότητας (προεπιλογή distance1). Αν το trim είναι true (προεπιλογή), και οι δύο οντότητες κόβονται στη γραμμή λοξότμησης. Η chamfer είναι ψευδώνυμο της bevel.

var a = addLine(0,0, 100,0);
var b = addLine(100,0, 100,50);
bevel(a, b, 10);

var c = addLine(0,100, 100,100);
var d = addLine(100,100, 100,150);
chamfer(c, d, 20, 10);

offset

offset(entity, distance)
offset(entity, distance, number)
offset(entity, distance, number, side)
offset(entity, sidePos, distance)
offset(entity, sidePos, distance, number)

Δημιουργεί παράλληλες σε γραμμές, ομόκεντρα τόξα και κύκλους ή παράλληλες καμπύλες ελλείψεων και άλλων οντοτήτων. Το number είναι ο αριθμός των παράλληλων που θα δημιουργηθούν (προεπιλογή 1). Οι παράλληλες δημιουργούνται και στις δύο πλευρές της οντότητας, εκτός αν δοθεί μια πλευρά, είτε ως θέση sidePos δίπλα στην οντότητα είτε ως side (RS.LeftHand, RS.RightHand ή RS.BothSides). Η μετατόπιση πολυγραμμών και splines είναι διαθέσιμη μόνο στο QCAD Professional.

var line = addLine(0,0, 100,0);
offset(line, 5);                 // μία παράλληλη σε κάθε πλευρά

var line2 = addLine(0,30, 100,30);
offset(line2, 5, 2, RS.LeftHand);    // δύο παράλληλες στην αριστερή πλευρά (από πάνω)

var circle = addCircle(50,80, 10);
offset(circle, [50,95], 3, 4);   // τέσσερις ομόκεντροι κύκλοι προς τα έξω

reverse

reverse(entity)
reverse(x, y)

Αντιστρέφει την κατεύθυνση της δεδομένης οντότητας, δηλαδή εναλλάσσει το σημείο αρχής και το τελικό σημείο της.

var line = addLine(0,0, 100,0);
line = reverse(line);
line.getStartPoint();            // επιστρέφει 100,0

explode

explode(entity)
explode(entity, options)
explode(x, y)

Διασπά τη δεδομένη οντότητα σε απλούστερες οντότητες: πολυγραμμές σε γραμμές και τόξα, αναφορές μπλοκ στο περιεχόμενό τους, κείμενα σε γραμμές και splines, διαστάσεις και διαγραμμίσεις σε γραμμές, τόξα κ.λπ. Η αρχική οντότητα διαγράφεται.

Το options είναι ένα προαιρετικό αντικείμενο με ρυθμίσεις που διαφορετικά λαμβάνονται από τις προτιμήσεις της εφαρμογής, για παράδειγμα { splineSegments: 64, textToPolylines: true }. Οι υποστηριζόμενες επιλογές είναι: splineTolerance, splineSegments, ellipseSegments, splinesToLineSegments, textToPolylines, textSplineToLineOrArc, multilineTextToSimpleText και circlesToPolylines.

var pl = addPolyline([[0,0], [100,0,1], [100,50], [0,50]], true);
explode(pl);                     // τρεις γραμμές και ένα τόξο

stretch

stretch(x1, y1, x2, y2, dx, dy)
stretch([x1, y1], [x2, y2], [dx, dy])
stretch(area, offset)

Τεντώνει (έκταση) όλες τις οντότητες στην ορθογώνια περιοχή που ορίζεται από δύο γωνίες κατά τη δεδομένη μετατόπιση. Οι οντότητες που βρίσκονται εξ ολοκλήρου μέσα στην περιοχή μετακινούνται, ενώ οι οντότητες που διασχίζουν το όριο της περιοχής τεντώνονται (μετακινούνται μόνο τα τελικά σημεία που βρίσκονται μέσα στην περιοχή). Η περιοχή μπορεί επίσης να δοθεί ως RBox ή ως κλειστό σχήμα RPolyline. Αν υπάρχουν επιλεγμένες οντότητες στο σχέδιο, τεντώνονται μόνο οι επιλεγμένες οντότητες.

// ένα ορθογώνιο από γραμμές:
addLine(0,0, 100,0);
addLine(100,0, 100,50);
addLine(100,50, 0,50);
addLine(0,50, 0,0);

// το ορθογώνιο γίνεται 50 μονάδες φαρδύτερο με τέντωμα της δεξιάς πλευράς του:
stretch([80,-10], [120,60], [50,0]);

deleteEntity

deleteEntity(entity)
deleteEntity(id)
deleteEntity(x, y)

Διαγράφει τη δεδομένη οντότητα από το σχέδιο.

var l1 = addLine(0,0, 100,0);
var l2 = addLine(0,10, 100,10);
addLine(0,20, 100,20);

deleteEntity(l1);                // μέσω οντότητας
deleteEntity(l2.getId());        // μέσω ID οντότητας
deleteEntity(50,20);             // μέσω θέσης

paste

paste(sourceDocument, destination, offset, scale, rotation,
      flipHorizontal, flipVertical, toCurrentLayer, overwriteLayers, overwriteBlocks)

Επικολλά το περιεχόμενο του εγγράφου sourceDocument στη διεπαφή εγγράφου destination ή στο τρέχον σχέδιο αν το destination είναι undefined. Το επικολλημένο περιεχόμενο μετακινείται κατά offset, κλιμακώνεται κατά scale και περιστρέφεται κατά rotation μοίρες. Όλα τα ορίσματα είναι υποχρεωτικά:

• flipHorizontal, flipVertical: true για αναστροφή του περιεχομένου
• toCurrentLayer: true για επικόλληση όλων των οντοτήτων στο τρέχον στρώμα
• overwriteLayers, overwriteBlocks: true για αντικατάσταση υπαρχόντων στρωμάτων ή μπλοκ με το ίδιο όνομα

// δημιουργία ενός συμβόλου σε έγγραφο εκτός οθόνης:
var symbol = createDocument();
startTransaction(symbol);
addCircle(0,0, 10);
addLine(-10,0, 10,0);
addLine(0,-10, 0,10);
endTransaction();

// επικόλληση τρεις φορές στο τρέχον σχέδιο:
for (var i=0; i<3; i++) {
    paste(symbol, undefined, [i*50, 0], 1+i*0.5, i*15, false, false, false, false, false);
}

Συναλλαγές

startTransaction και endTransaction

startTransaction()
startTransaction(document)
endTransaction()

Από προεπιλογή, κάθε κλήση του Simple API εφαρμόζεται αμέσως στο σχέδιο και μπορεί να αναιρεθεί μεμονωμένα. Μεταξύ startTransaction() και endTransaction(), όλες οι αλλαγές συλλέγονται και εφαρμόζονται μαζί όταν καλείται η endTransaction. Αυτό έχει δύο πλεονεκτήματα:

• Είναι πολύ ταχύτερο όταν προστίθενται πολλές οντότητες.
• Όλες οι αλλαγές μπορούν να αναιρεθούν σε ένα μόνο βήμα.

Αν δοθεί ένα έγγραφο (RDocument) ή μια διεπαφή εγγράφου (RDocumentInterface) στην startTransaction, όλες οι αλλαγές εφαρμόζονται σε αυτό το έγγραφο αντί για το τρέχον σχέδιο. Αυτό είναι χρήσιμο για τη δημιουργία σχεδίων στο παρασκήνιο, για παράδειγμα για την εξαγωγή τους σε αρχείο (δείτε createDocumentInterface).

startTransaction();
for (var x=0; x<=200; x+=10) {
    for (var y=0; y<=200; y+=10) {
        addPoint(x, y);
    }
}
endTransaction();

Λάβετε υπόψη τα εξής όταν εργάζεστε με συναλλαγές:

• Μέσα σε μια συναλλαγή, οι αλλαγές δεν αποτελούν ακόμη μέρος του σχεδίου. Οι συναρτήσεις τροποποίησης, όπως η trim ή η round, δεν μπορούν να αναφερθούν σε οντότητες που προστέθηκαν στην ίδια συναλλαγή.
• Οι οντότητες που επιστρέφονται από συναρτήσεις δημιουργίας μέσα σε μια συναλλαγή δεν έχουν έγκυρο ID, ούτε καν μετά την endTransaction. Για να τροποποιήσετε τέτοιες οντότητες αργότερα, αναφερθείτε σε αυτές μέσω θέσης.
• Όλες οι οντότητες που προστίθενται μέσα σε μια συναλλαγή τοποθετούνται στο στρώμα που είναι τρέχον όταν καλείται η endTransaction. Ορίστε το τρέχον στρώμα πριν ξεκινήσετε τη συναλλαγή και χρησιμοποιήστε ξεχωριστές συναλλαγές για διαφορετικά στρώματα.

startTransaction();
addLine(0,0, 100,0);
addLine(100,0, 100,50);
endTransaction();

// αναφορά στις νέες γραμμές μέσω θέσης για στρογγυλοποίηση της γωνίας:
round([50,0], [100,25], 10);

getTransactionDocument και getTransactionDocumentInterface

getTransactionDocument()
getTransactionDocumentInterface()

Επιστρέφουν το έγγραφο ή τη διεπαφή εγγράφου στην οποία εφαρμόζεται η τρέχουσα συναλλαγή. Εκτός συναλλαγών, επιστρέφονται το τρέχον έγγραφο και η τρέχουσα διεπαφή εγγράφου.

var doc = createDocument();
startTransaction(doc);
addLine(0,0, 10,0);
getTransactionDocument() === doc;    // επιστρέφει true
endTransaction();

getOperation

getOperation()

Επιστρέφει τη λειτουργία (RAddObjectsOperation) της τρέχουσας συναλλαγής. Εκτός συναλλαγής, επιστρέφεται μια νέα λειτουργία που πρέπει να εφαρμοστεί ρητά. Αυτό προορίζεται για προχωρημένη χρήση, για παράδειγμα για συνδυασμό κλήσεων του Simple API με το πλήρες API του QCAD.

startTransaction();
addCircle(0,0, 10);
var doc = getTransactionDocument();
var e = new RLineEntity(doc, new RLineData(new RVector(-10,0), new RVector(10,0)));
getOperation().addObject(e);
endTransaction();

Προβολή

autoZoom

autoZoom()

Μεγεθύνει την τρέχουσα προβολή ώστε να είναι ορατό ολόκληρο το σχέδιο.

addCircle(1000,1000, 500);
autoZoom();

zoomTo

zoomTo(entity)
zoomTo(entity, margin)
zoomTo([x1, y1], [x2, y2])
zoomTo([x1, y1], [x2, y2], margin)
zoomTo(box, margin)

Κάνει ζουμ στη δεδομένη οντότητα, στο σχήμα ή στην ορθογώνια περιοχή. Το margin είναι το περιθώριο γύρω από την περιοχή σε pixel (προεπιλογή 10).

addCircle(0,0, 100);
var small = addCircle(80,0, 2);
zoomTo(small, 50);

zoomTo([0,0], [100,100]);

Έγγραφα και εφαρμογή

getMainWindow

getMainWindow()

Επιστρέφει το παράθυρο της εφαρμογής QCAD (RMainWindowQt).

getMainWindow().windowTitle;

getDocumentInterface

getDocumentInterface()

Επιστρέφει τη διεπαφή εγγράφου (RDocumentInterface) του τρέχοντος σχεδίου. Η διεπαφή εγγράφου συνδέει ένα έγγραφο με τις προβολές του και παρέχει συναρτήσεις για εισαγωγή και εξαγωγή αρχείων, εφαρμογή λειτουργιών, αναίρεση και επανάληψη.

addLine(0,0, 100,0);
getDocumentInterface().undo();       // αφαιρεί ξανά τη γραμμή

getDocument

getDocument()

Επιστρέφει το τρέχον έγγραφο (RDocument). Το έγγραφο περιέχει όλες τις οντότητες, τα στρώματα, τα μπλοκ κ.λπ. ενός σχεδίου και παρέχει συναρτήσεις για την αναζήτησή τους.

addLine(0,0, 100,0);
addCircle(0,0, 10);
getDocument().queryAllEntities().length;     // αριθμός οντοτήτων στο σχέδιο

getGraphicsView

getGraphicsView()

Επιστρέφει την τρέχουσα ή την τελευταία ενεργή προβολή (RGraphicsView) του τρέχοντος σχεδίου.

addCircle(0,0, 50);
getGraphicsView().autoZoom();

createDocument

createDocument()

Δημιουργεί ένα νέο, κενό έγγραφο στη μνήμη που δεν εμφανίζεται σε παράθυρο. Ένα τέτοιο έγγραφο εκτός οθόνης μπορεί να γεμίσει με τη χρήση μιας συναλλαγής και στη συνέχεια να επικολληθεί σε ένα σχέδιο (δείτε paste).

var doc = createDocument();
startTransaction(doc);
addLine(0,0, 100,0);
addLine(100,0, 100,100);
endTransaction();

doc.queryAllEntities().length;       // επιστρέφει 2

createDocumentInterface

createDocumentInterface()

Δημιουργεί ένα νέο, κενό έγγραφο στη μνήμη μαζί με μια διεπαφή εγγράφου. Η διεπαφή εγγράφου μπορεί να χρησιμοποιηθεί για την εισαγωγή ή την εξαγωγή αρχείων.

var di = createDocumentInterface();
startTransaction(di);
addCircle(0,0, 50);
addSimpleText("Created by script", [-40,-60], 5);
endTransaction();

di.exportFile(QDir.homePath() + "/simple_api_example.dxf", "R27 (2013) DXF");

disableInput, enableInput και isInputEnabled

disableInput()
enableInput()
isInputEnabled()

Η disableInput απενεργοποιεί το παράθυρο της εφαρμογής QCAD για να αποτρέψει την είσοδο του χρήστη, για παράδειγμα κατά τη διάρκεια μακροσκελών λειτουργιών ή κινούμενων εικόνων. Η enableInput ενεργοποιεί ξανά το παράθυρο της εφαρμογής και η isInputEnabled επιστρέφει true αν η είσοδος του χρήστη είναι αυτή τη στιγμή ενεργοποιημένη. Βεβαιωθείτε πάντα ότι ενεργοποιείτε ξανά την είσοδο στο τέλος του σεναρίου σας.

update

update()

Επεξεργάζεται τα εκκρεμή συμβάντα, ώστε η διεπαφή χρήστη να ενημερώνεται κατά τη διάρκεια μακροσκελών λειτουργιών. Η είσοδος του χρήστη πρέπει να έχει απενεργοποιηθεί με την disableInput πριν από την κλήση της update.

sleep

sleep(milliseconds)

Διακόπτει προσωρινά το σενάριο για τον δεδομένο χρόνο σε χιλιοστά του δευτερολέπτου, διατηρώντας παράλληλα ενημερωμένη τη διεπαφή χρήστη. Η είσοδος του χρήστη πρέπει να έχει απενεργοποιηθεί με την disableInput πριν από την κλήση της sleep.

Το παρακάτω παράδειγμα χρησιμοποιεί τις disableInput, sleep και enableInput για να εμφανίσει μια απλή κινούμενη εικόνα:

disableInput();
var c = addCircle(0,0, 10);
autoZoom();
for (var i=0; i<20; i++) {
    c = move(c, 5,0);
    sleep(50);
}
enableInput();

warning

warning(message)

Εμφανίζει ένα μήνυμα προειδοποίησης. Στο Script Shell, οι προειδοποιήσεις εμφανίζονται στο ιστορικό εντολών. Διαφορετικά, οι προειδοποιήσεις τυπώνονται στην κονσόλα.

if (getDocument().queryAllEntities().length===0) {
    warning("The drawing is empty.");
}

Είσοδος χρήστη

Οι παρακάτω συναρτήσεις εμφανίζουν ένα απλό παράθυρο διαλόγου για να ζητήσουν από τον χρήστη μια τιμή. Αν ο χρήστης ακυρώσει το παράθυρο διαλόγου, επιστρέφεται undefined.

getInt

getInt(title, prompt, value, step, min, max)

Ζητά από τον χρήστη έναν ακέραιο αριθμό. Το value είναι η αρχική τιμή (προεπιλογή 0), το step το βήμα του πεδίου αριθμού με βέλη (spin box) (προεπιλογή 1), τα min και max το επιτρεπόμενο εύρος.

var n = getInt("Circles", "Number of circles:", 5, 1, 1, 100);
if (isNull(n)) {
    warning("Canceled.");
}
else {
    for (var i=1; i<=n; i++) {
        addCircle(0,0, i*10);
    }
}

getDouble

getDouble(title, prompt, value, decimals, min, max)

Ζητά από τον χρήστη έναν αριθμό. Το value είναι η αρχική τιμή (προεπιλογή 0), το decimals ο αριθμός των δεκαδικών ψηφίων που εμφανίζονται (προεπιλογή 1), τα min και max το επιτρεπόμενο εύρος.

var r = getDouble("Circle", "Radius:", 25.0, 2, 0.01, 1000);
if (!isNull(r)) {
    addCircle(0,0, r);
}

getText

getText(title, prompt, text)

Ζητά από τον χρήστη ένα κείμενο. Το text είναι το αρχικό κείμενο (προεπιλογή κενό).

var t = getText("Label", "Text:", "Hello");
if (!isNull(t)) {
    addSimpleText(t, 0,0, 10);
}

getItem

getItem(title, prompt, items, index, separator)

Επιτρέπει στον χρήστη να επιλέξει ένα στοιχείο από μια αναπτυσσόμενη λίστα. Το items είναι μια συμβολοσειρά με όλα τα στοιχεία χωρισμένα με separator (προεπιλογή ","). Το index είναι ο δείκτης του αρχικά επιλεγμένου στοιχείου (προεπιλογή 0). Επιστρέφει το επιλεγμένο στοιχείο ή undefined αν ακυρώθηκε το παράθυρο διαλόγου.

var shape = getItem("Shape", "Shape to add:", "Circle,Square,Triangle", 0);
if (shape==="Circle") {
    addCircle(0,0, 50);
}
else if (shape==="Square") {
    addPolyline([[-50,-50], [50,-50], [50,50], [-50,50]], true);
}
else if (shape==="Triangle") {
    addPolyline([[-50,-50], [50,-50], [0,50]], true);
}

Παράδειγμα: Μια φλάντζα

Αυτό το παράδειγμα συνδυάζει διάφορες συναρτήσεις του Simple API για να σχεδιάσει μια φλάντζα με κύκλο κέντρων οπών, οπές κοχλιών σε ξεχωριστό στρώμα και ένα ορθογώνιο άνοιγμα με στρογγυλεμένες γωνίες:

addLayer("Center Lines", "gray", "CENTER");
addLayer("Holes", "red");

// περίγραμμα:
setCurrentLayer("0");
addCircle(0,0, 100);

// κύκλος κέντρων οπών και αξονικές γραμμές:
setCurrentLayer("Center Lines");
addCircle(0,0, 75);
addLine(-110,0, 110,0);
addLine(0,-110, 0,110);

// οπές κοχλιών, προστίθενται σε μία συναλλαγή:
setCurrentLayer("Holes");
startTransaction();
for (var a=0; a<360; a+=45) {
    var angle = a * Math.PI / 180;
    addCircle(75*Math.cos(angle), 75*Math.sin(angle), 8);
}
endTransaction();

// τετράγωνο άνοιγμα με στρογγυλεμένες γωνίες στο κέντρο:
setCurrentLayer("0");
var l1 = addLine(-30,-30, 30,-30);
var l2 = addLine(30,-30, 30,30);
var l3 = addLine(30,30, -30,30);
var l4 = addLine(-30,30, -30,-30);
round(l1, l2, 8);
round(l2, l3, 8);
round(l3, l4, 8);
round(l4, l1, 8);

autoZoom();

Οι γραμμές του ανοίγματος προστίθενται χωρίς συναλλαγή, ώστε να μπορούν να δοθούν απευθείας στη round. Οι οπές κοχλιών προστίθενται σε μια συναλλαγή, κάτι που είναι ταχύτερο και επιτρέπει την αναίρεσή τους σε ένα βήμα.