import os
import PySide.QtCore as QtCore
import FreeCAD as App
from draftutils import params
from draftutils.messages import _wrn, _err, _log
from draftutils.translate import translate
from builtins import open
if App.GuiUp:
import FreeCADGui as Gui
import Draft_rc
True if Draft_rc else False
ARROW_TYPES = ["Dot", "Circle", "Arrow", "Tick", "Tick-2", "None"]
DISPLAY_MODES = ["Flat Lines", "Shaded", "Wireframe", "Points"]
DRAW_STYLES = ["Solid", "Dashed", "Dotted", "Dashdot"]
arrowtypes = ARROW_TYPES
def get_default_annotation_style():
arrow_start_type_index = params.get_param("dimsymbolstart")
arrow_end_type_index = params.get_param("dimsymbolend")
return {
"ArrowSizeStart": ("float", params.get_param("arrowsizestart")),
"ArrowSizeEnd": ("float", params.get_param("arrowsizeend")),
"ArrowTypeStart": ("index", arrow_start_type_index, ARROW_TYPES[arrow_start_type_index]),
"ArrowTypeEnd": ("index", arrow_end_type_index, ARROW_TYPES[arrow_end_type_index]),
"Decimals": ("int", params.get_param("dimPrecision")),
"DimOvershoot": ("float", params.get_param("dimovershoot")),
"ExtLines": ("float", params.get_param("extlines")),
"ExtOvershoot": ("float", params.get_param("extovershoot")),
"FontName": ("font", params.get_param("textfont")),
"FontSize": ("float", params.get_param("textheight")),
"LineColor": ("color", params.get_param("DefaultAnnoLineColor") | 0x000000FF),
"LineSpacing": ("float", params.get_param("LineSpacing")),
"LineWidth": ("int", params.get_param("DefaultAnnoLineWidth")),
"ScaleMultiplier": ("float", params.get_param("DefaultAnnoScaleMultiplier")),
"ShowLine": ("bool", params.get_param("DimShowLine")),
"ShowUnit": ("bool", params.get_param("showUnit")),
"TextColor": ("color", params.get_param("DefaultTextColor") | 0x000000FF),
"TextSpacing": ("float", params.get_param("dimspacing")),
"UnitOverride": ("str", params.get_param("overrideUnit")),
}
def repair_annotation_style(style):
for key in ("ArrowSize", "ArrowType"):
if (
style.get(key) is not None
and style.get(key + "Start") is None
and style.get(key + "End") is None
):
style[key + "Start"] = style[key]
style[key + "End"] = style[key]
default = get_default_annotation_style()
new = {}
for key, val in default.items():
if style.get(key) is None:
new[key] = val[1]
elif type(style[key]) == type(val[1]):
new[key] = style[key]
elif isinstance(style[key], str):
new[key] = float(style[key].replace(",", "."))
else:
new[key] = val[1]
return new
def get_default_shape_style():
display_mode_index = params.get_param("DefaultDisplayMode")
draw_style_index = params.get_param("DefaultDrawStyle")
return {
"DisplayMode": ("index", display_mode_index, DISPLAY_MODES[display_mode_index]),
"DrawStyle": ("index", draw_style_index, DRAW_STYLES[draw_style_index]),
"LineColor": ("color", params.get_param_view("DefaultShapeLineColor") | 0x000000FF),
"LineWidth": ("int", params.get_param_view("DefaultShapeLineWidth")),
"PointColor": ("color", params.get_param_view("DefaultShapeVertexColor") | 0x000000FF),
"PointSize": ("int", params.get_param_view("DefaultShapePointSize")),
"ShapeAppearance": ("material", (get_view_material(),)),
}
def get_view_material():
material = App.Material()
material.AmbientColor = params.get_param_view("DefaultAmbientColor") | 0x000000FF
material.DiffuseColor = params.get_param_view("DefaultShapeColor") | 0x000000FF
material.EmissiveColor = params.get_param_view("DefaultEmissiveColor") | 0x000000FF
material.Shininess = params.get_param_view("DefaultShapeShininess") / 100
material.SpecularColor = params.get_param_view("DefaultSpecularColor") | 0x000000FF
material.Transparency = params.get_param_view("DefaultShapeTransparency") / 100
return material
def string_encode_coin(ustr):
try:
from pivy import coin
coin4 = coin.COIN_MAJOR_VERSION >= 4
except (ImportError, AttributeError):
coin4 = False
if coin4:
return ustr.encode("utf-8")
else:
return ustr.encode("latin1")
stringencodecoin = string_encode_coin
def type_check(args_and_types, name="?"):
for v, t in args_and_types:
if not isinstance(v, t):
w = "typecheck[{}]: '{}' is not {}".format(name, v, t)
_err(w)
raise TypeError("Draft." + str(name))
typecheck = type_check
def precision():
return params.get_param("precision")
def svg_precision():
return params.get_param("svgPrecision")
def tolerance():
return 10 ** -precision()
def is_deleted(obj):
try:
return not obj.isAttachedToDocument()
except:
return True
def get_real_name(name):
for i in range(1, len(name) + 1):
if name[-i] not in "1234567890":
return name[: len(name) - (i - 1)]
return name
getRealName = get_real_name
def get_type(obj):
import Part
if not obj:
return None
if isinstance(obj, Part.Shape):
return "Shape"
if hasattr(obj, "Class") and "Ifc" in str(obj.Class):
return obj.Class
if hasattr(obj, "Proxy") and hasattr(obj.Proxy, "Type"):
return obj.Proxy.Type
if hasattr(obj, "TypeId"):
return obj.TypeId
return "Unknown"
getType = get_type
def get_objects_of_type(objects, typ):
objs = []
for o in objects:
if getType(o) == typ:
objs.append(o)
return objs
getObjectsOfType = get_objects_of_type
def is_clone(obj, objtype=None, recursive=False):
if isinstance(objtype, list):
return any([is_clone(obj, t, recursive) for t in objtype])
if getType(obj) == "Clone":
if len(obj.Objects) == 1:
if objtype:
if getType(obj.Objects[0]) == objtype:
return True
elif recursive and (getType(obj.Objects[0]) == "Clone"):
return is_clone(obj.Objects[0], objtype, recursive)
elif hasattr(obj, "CloneOf"):
if obj.CloneOf:
if objtype:
if getType(obj.CloneOf) == objtype:
return True
else:
return True
return False
isClone = is_clone
def get_clone_base(obj, strict=False, recursive=True):
if hasattr(obj, "CloneOf") and obj.CloneOf:
if recursive:
return get_clone_base(obj.CloneOf)
return obj.CloneOf
if get_type(obj) == "Clone" and obj.Objects:
if recursive:
return get_clone_base(obj.Objects[0])
return obj.Objects[0]
if strict:
return False
return obj
getCloneBase = get_clone_base
def shapify(obj, delete=True):
try:
shape = obj.Shape
except Exception:
return None
if len(shape.Faces) == 1:
name = "Face"
elif len(shape.Solids) == 1:
name = "Solid"
elif len(shape.Solids) > 1:
name = "Compound"
elif len(shape.Faces) > 1:
name = "Shell"
elif len(shape.Wires) == 1:
name = "Wire"
elif len(shape.Edges) == 1:
import DraftGeomUtils
if DraftGeomUtils.geomType(shape.Edges[0]) == "Line":
name = "Line"
else:
name = "Circle"
else:
name = getRealName(obj.Name)
if delete:
App.ActiveDocument.removeObject(obj.Name)
newobj = App.ActiveDocument.addObject("Part::Feature", name)
newobj.Shape = shape
return newobj
def print_shape(shape):
_msg(translate("draft", "Solids:") + " {}".format(len(shape.Solids)))
_msg(translate("draft", "Faces:") + " {}".format(len(shape.Faces)))
_msg(translate("draft", "Wires:") + " {}".format(len(shape.Wires)))
_msg(translate("draft", "Edges:") + " {}".format(len(shape.Edges)))
_msg(translate("draft", "Vertices:") + " {}".format(len(shape.Vertexes)))
if shape.Faces:
for f in range(len(shape.Faces)):
_msg(translate("draft", "Face") + " {}:".format(f))
for v in shape.Faces[f].Vertexes:
_msg(" {}".format(v.Point))
elif shape.Wires:
for w in range(len(shape.Wires)):
_msg(translate("draft", "Wire") + " {}:".format(w))
for v in shape.Wires[w].Vertexes:
_msg(" {}".format(v.Point))
else:
for v in shape.Vertexes:
_msg(" {}".format(v.Point))
printShape = print_shape
def compare_objects(obj1, obj2):
if obj1.TypeId != obj2.TypeId:
_msg(
"'{0}' ({1}), '{2}' ({3}): ".format(obj1.Name, obj1.TypeId, obj2.Name, obj2.TypeId)
+ translate("draft", "different types")
+ " (TypeId)"
)
elif getType(obj1) != getType(obj2):
_msg(
"'{0}' ({1}), '{2}' ({3}): ".format(
obj1.Name, get_type(obj1), obj2.Name, get_type(obj2)
)
+ translate("draft", "different types")
+ " (Proxy.Type)"
)
else:
for p in obj1.PropertiesList:
if p in obj2.PropertiesList:
if p in ("Shape", "Label"):
pass
elif p == "Placement":
delta = obj1.Placement.Base.sub(obj2.Placement.Base)
text = translate(
"draft",
"Objects have different placements. "
"Distance between the two base points:",
)
_msg(text + " " + str(delta.Length))
else:
if getattr(obj1, p) != getattr(obj2, p):
_msg("'{}' ".format(p) + translate("draft", "has a different value"))
else:
_msg("{} ".format(p) + translate("draft", "doesn't exist in one of the objects"))
compareObjects = compare_objects
def load_svg_patterns():
import importSVG
App.svgpatterns = {}
patfiles = QtCore.QDir(":/patterns").entryList()
for fn in patfiles:
file = ":/patterns/" + str(fn)
f = QtCore.QFile(file)
f.open(QtCore.QIODevice.ReadOnly)
p = importSVG.getContents(str(f.readAll()), "pattern", True)
if p:
for k in p:
p[k] = [p[k], file]
App.svgpatterns.update(p)
altpat = params.get_param("patternFile")
if os.path.isdir(altpat):
for f in os.listdir(altpat):
if f[-4:].upper() == ".SVG":
file = os.path.join(altpat, f)
p = importSVG.getContents(file, "pattern")
if p:
for k in p:
p[k] = [p[k], file]
App.svgpatterns.update(p)
altpat = os.path.join(App.getResourceDir(), "Mod", "TechDraw", "Patterns")
if os.path.isdir(altpat):
for f in os.listdir(altpat):
if f[-4:].upper() == ".SVG":
file = os.path.join(altpat, f)
p = importSVG.getContents(file, "pattern")
if p:
for k in p:
p[k] = [p[k], file]
else:
p = {f[:-4]: ["<pattern></pattern>", file]}
App.svgpatterns.update(p)
loadSvgPatterns = load_svg_patterns
def svg_patterns():
if hasattr(App, "svgpatterns"):
return App.svgpatterns
else:
loadSvgPatterns()
if hasattr(App, "svgpatterns"):
return App.svgpatterns
return {}
svgpatterns = svg_patterns
def get_rgb(color, testbw=True):
r = str(hex(int(color[0] * 255)))[2:].zfill(2)
g = str(hex(int(color[1] * 255)))[2:].zfill(2)
b = str(hex(int(color[2] * 255)))[2:].zfill(2)
col = "#" + r + g + b
if testbw:
if col == "#ffffff":
if params.get_param("SvgLinesBlack"):
col = "#000000"
return col
getrgb = get_rgb
def argb_to_rgba(color):
return ((color & 0xFFFFFF) << 8) + ((color & 0xFF000000) >> 24)
def rgba_to_argb(color):
return ((color & 0xFFFFFF00) >> 8) + ((color & 0xFF) << 24)
def get_rgba_tuple(color, typ=1.0):
color = ((color >> 24) & 0xFF, (color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF)
if type(typ) == float:
return tuple([x / 255.0 for x in color])
else:
return color
def _modifiers_process_subselection(sels, copy):
data_list = []
sel_info = []
for sel in sels:
for sub in sel.SubElementNames if sel.SubElementNames else [""]:
if not ("Vertex" in sub or "Edge" in sub):
continue
if copy and "Vertex" in sub:
continue
obj = sel.Object.getSubObject(sub, 1)
pla = sel.Object.getSubObject(sub, 3)
if "Vertex" in sub:
vert_idx = int(sub.rpartition("Vertex")[2]) - 1
edge_idx = -1
else:
vert_idx = -1
edge_idx = int(sub.rpartition("Edge")[2]) - 1
data_list.append((obj, vert_idx, edge_idx, pla))
sel_info.append(("", sel.Object.Name, sub))
return data_list, sel_info
def _modifiers_process_selection(sels, copy, scale=False, add_movable_children=False):
objects = []
places = []
sel_info = []
for sel in sels:
for sub in sel.SubElementNames if sel.SubElementNames else [""]:
obj = sel.Object.getSubObject(sub, 1)
if obj == sel.Object:
pla = App.Placement()
else:
pla = sel.Object.getSubObject(sub.rpartition(obj.Name)[0], 3)
objs = _modifiers_get_group_contents(obj)
if add_movable_children:
children = []
for obj in objs:
children.extend(_modifiers_get_movable_children(obj))
objs.extend(children)
objs = _modifiers_filter_objects(objs, copy, scale)
objects.extend(objs)
places.extend(len(objs) * [pla])
if "." in sub:
sub = sub.rpartition(".")[0] + "."
elif "Face" in sub or "Edge" in sub or "Vertex" in sub:
sub = ""
sel_info.append(("", sel.Object.Name, sub))
return objects, places, sel_info
def _modifiers_get_group_contents(obj):
from draftutils import groups
return groups.get_group_contents(obj, addgroups=True, spaces=True, noarchchild=True)
def _modifiers_get_movable_children(obj):
result = []
if hasattr(obj, "Proxy") and hasattr(obj.Proxy, "getMovableChildren"):
children = obj.Proxy.getMovableChildren(obj)
result.extend(children)
for child in children:
result.extend(_modifiers_get_movable_children(child))
return result
def _modifiers_filter_objects(objs, copy, scale=False):
def is_scalable(obj):
if hasattr(obj, "Placement") and hasattr(obj, "Shape"):
return True
if obj.isDerivedFrom("App::DocumentObjectGroup"):
return True
if obj.isDerivedFrom("App::Annotation"):
return True
if obj.isDerivedFrom("Image::ImagePlane"):
return True
return False
result = []
for obj in objs:
if not copy and hasattr(obj, "MoveBase") and obj.MoveBase and obj.Base:
parents = []
for parent in obj.Base.InList:
if parent.isDerivedFrom("Part::Feature"):
parents.append(parent.Name)
if len(parents) > 1:
message = translate(
"draft",
"%s shares a base with %d other objects. Please check if you want to modify this.",
) % (obj.Name, len(parents) - 1)
_err(message)
if not scale or utils.get_type(obj.Base) == "Wire":
result.append(obj.Base)
elif (
not copy and hasattr(obj, "Placement") and "ReadOnly" in obj.getEditorMode("Placement")
):
_err(
translate("draft", "%s cannot be modified because its placement is readonly")
% obj.Name
)
elif not scale or is_scalable(obj):
result.append(obj)
return result
def is_closed_edge(edge_index, object):
return edge_index + 1 >= len(object.Points)
def utf8_decode(text):
try:
return text.decode("utf-8")
except AttributeError:
return text
def print_header(name, description, debug=True):
_log(name)
if debug:
_msg(16 * "-")
_msg(description)
def find_doc(doc=None):
FOUND = True
if not doc:
doc = App.activeDocument()
if not doc:
return not FOUND, None
if isinstance(doc, str):
try:
doc = App.getDocument(doc)
except NameError:
_err(translate("draft", "Wrong input: unknown document {}").format(doc))
return not FOUND, None
return FOUND, doc
def find_object(obj, doc=None):
FOUND = True
found, doc = find_doc(doc)
if not found:
_err(translate("draft", "No active document. Aborting."))
return not FOUND, None
if isinstance(obj, str):
try:
obj = doc.getObjectsByLabel(obj)[0]
except IndexError:
return not FOUND, None
if obj not in doc.Objects:
return not FOUND, None
return FOUND, obj
def use_instead(function, version=""):
if version:
_wrn(
translate("draft", "This function will be deprecated in {}. Please use '{}'.").format(
version, function
)
)
else:
_wrn(
translate("draft", "This function will be deprecated. Please use '{}'.").format(
function
)
)
def pyopen(
file,
mode="r",
buffering=-1,
encoding=None,
errors=None,
newline=None,
closefd=True,
opener=None,
):
if encoding is None:
encoding = "utf-8"
return open(file, mode, buffering, encoding, errors, newline, closefd, opener)