Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
/*
* LibrePCB - Professional EDA for everyone!
* Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
* https://librepcb.org/
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*******************************************************************************
* Includes
******************************************************************************/
#include "cmdpasteschematicitems.h"
#include "../../graphics/imagegraphicsitem.h"
#include "../../graphics/polygongraphicsitem.h"
#include "../../project/cmd/cmdbusadd.h"
#include "../../project/cmd/cmdcomponentinstanceadd.h"
#include "../../project/cmd/cmdcompsiginstsetnetsignal.h"
#include "../../project/cmd/cmdnetclassadd.h"
#include "../../project/cmd/cmdnetsignaladd.h"
#include "../../project/cmd/cmdnetsignaledit.h"
#include "../../project/cmd/cmdprojectlibraryaddelement.h"
#include "../../project/cmd/cmdschematicbuslabeladd.h"
#include "../../project/cmd/cmdschematicbussegmentadd.h"
#include "../../project/cmd/cmdschematicbussegmentaddelements.h"
#include "../../project/cmd/cmdschematicimageadd.h"
#include "../../project/cmd/cmdschematicnetlabeladd.h"
#include "../../project/cmd/cmdschematicnetsegmentadd.h"
#include "../../project/cmd/cmdschematicnetsegmentaddelements.h"
#include "../../project/cmd/cmdschematicpolygonadd.h"
#include "../../project/cmd/cmdschematictextadd.h"
#include "../../project/cmd/cmdsymbolinstanceadd.h"
#include "../../utils/imagehelpers.h"
#include "../schematic/graphicsitems/sgi_busjunction.h"
#include "../schematic/graphicsitems/sgi_buslabel.h"
#include "../schematic/graphicsitems/sgi_busline.h"
#include "../schematic/graphicsitems/sgi_netlabel.h"
#include "../schematic/graphicsitems/sgi_netline.h"
#include "../schematic/graphicsitems/sgi_netpoint.h"
#include "../schematic/graphicsitems/sgi_symbol.h"
#include "../schematic/graphicsitems/sgi_text.h"
#include "../schematic/schematicclipboarddata.h"
#include "../schematic/schematicgraphicsscene.h"
#include "cmdchangenetsignalofschematicnetsegment.h"
#include <librepcb/core/library/cmp/component.h>
#include <librepcb/core/library/sym/symbol.h>
#include <librepcb/core/project/circuit/bus.h>
#include <librepcb/core/project/circuit/circuit.h>
#include <librepcb/core/project/circuit/componentinstance.h>
#include <librepcb/core/project/circuit/componentsignalinstance.h>
#include <librepcb/core/project/project.h>
#include <librepcb/core/project/projectlibrary.h>
#include <librepcb/core/project/schematic/items/si_busjunction.h>
#include <librepcb/core/project/schematic/items/si_buslabel.h>
#include <librepcb/core/project/schematic/items/si_busline.h>
#include <librepcb/core/project/schematic/items/si_bussegment.h>
#include <librepcb/core/project/schematic/items/si_image.h>
#include <librepcb/core/project/schematic/items/si_netlabel.h>
#include <librepcb/core/project/schematic/items/si_netline.h>
#include <librepcb/core/project/schematic/items/si_netpoint.h>
#include <librepcb/core/project/schematic/items/si_netsegment.h>
#include <librepcb/core/project/schematic/items/si_polygon.h>
#include <librepcb/core/project/schematic/items/si_symbol.h>
#include <librepcb/core/project/schematic/items/si_symbolpin.h>
#include <librepcb/core/project/schematic/items/si_text.h>
#include <librepcb/core/project/schematic/schematic.h>
#include <librepcb/core/utils/scopeguard.h>
#include <librepcb/core/utils/toolbox.h>
#include <QtCore>
#include <memory>
/*******************************************************************************
* Namespace
******************************************************************************/
namespace librepcb {
namespace editor {
/*******************************************************************************
* Constructors / Destructor
******************************************************************************/
CmdPasteSchematicItems::CmdPasteSchematicItems(
SchematicGraphicsScene& scene, std::unique_ptr<SchematicClipboardData> data,
const Point& posOffset) noexcept
: UndoCommandGroup(tr("Paste Schematic Elements")),
mScene(scene),
mSchematic(scene.getSchematic()),
mProject(mSchematic.getProject()),
mData(std::move(data)),
mPosOffset(posOffset) {
Q_ASSERT(mData);
}
CmdPasteSchematicItems::~CmdPasteSchematicItems() noexcept {
}
/*******************************************************************************
* Inherited from UndoCommand
******************************************************************************/
bool CmdPasteSchematicItems::performExecute() {
// if an error occurs, undo all already executed child commands
auto undoScopeGuard = scopeGuard([&]() { performUndo(); });
// Notes:
//
// - If a component name is already existing, generate a new name. Otherwise
// keep the original name.
// - The graphics items of the added elements are selected immediately to
// allow dragging them afterwards.
// Parts assembly variants conversion function. Work with blacklisting
// instead of whitelisting to avoid accidentally disappearing parts if
// some assembly variants do not exist in the pasted project.
auto convertAssemblyVariants = [this](const QSet<Uuid>& uuids) {
if (uuids.isEmpty()) {
return uuids; // Keep do-not-mount status!
}
QSet<Uuid> result =
mProject.getCircuit().getAssemblyVariants().getUuidSet();
for (const AssemblyVariant& oldAv : mData->getAssemblyVariants()) {
if (!uuids.contains(oldAv.getUuid())) {
if (result.contains(oldAv.getUuid())) {
result.remove(oldAv.getUuid());
} else if (auto newAv =
mProject.getCircuit().getAssemblyVariants().find(
*oldAv.getName())) {
result.remove(newAv->getUuid());
}
}
}
return result;
};
// Copy new components to project library
std::unique_ptr<TransactionalDirectory> cmpDir = mData->getDirectory("cmp");
foreach (const QString& dirname, cmpDir->getDirs()) {
if (!mProject.getLibrary().getComponent(Uuid::fromString(dirname))) {
std::unique_ptr<Component> cmp = Component::open(
std::make_unique<TransactionalDirectory>(*cmpDir, dirname));
execNewChildCmd(new CmdProjectLibraryAddElement<Component>(
mProject.getLibrary(), *cmp.release()));
}
}
// Copy new symbols to project library
std::unique_ptr<TransactionalDirectory> symDir = mData->getDirectory("sym");
foreach (const QString& dirname, symDir->getDirs()) {
if (!mProject.getLibrary().getSymbol(Uuid::fromString(dirname))) {
std::unique_ptr<Symbol> sym = Symbol::open(
std::make_unique<TransactionalDirectory>(*symDir, dirname));
execNewChildCmd(new CmdProjectLibraryAddElement<Symbol>(
mProject.getLibrary(), *sym.release()));
}
}
// Sort components by name to avoid a random mess, see
// https://github.com/LibrePCB/LibrePCB/issues/1418.
auto componentInstances = mData->getComponentInstances().values();
Toolbox::sortNumeric(
componentInstances,
[](const QCollator& cmp,
const std::shared_ptr<SchematicClipboardData::ComponentInstance>& a,
const std::shared_ptr<SchematicClipboardData::ComponentInstance>& b) {
return cmp(*a->name, *b->name);
});
// Paste components
QHash<Uuid, Uuid> componentInstanceMap;
for (const std::shared_ptr<SchematicClipboardData::ComponentInstance>& cmp :
std::as_const(componentInstances)) {
const Component* libCmp =
mProject.getLibrary().getComponent(cmp->libComponentUuid);
if (!libCmp) throw LogicError(__FILE__, __LINE__);
CircuitIdentifier name = cmp->name;
if (mProject.getCircuit().getComponentInstanceByName(*name)) {
name = CircuitIdentifier(
mProject.getCircuit().generateAutoComponentInstanceName(
libCmp->getPrefixes().value(mProject.getLocaleOrder())));
}
std::unique_ptr<ComponentInstance> copy(
new ComponentInstance(mProject.getCircuit(), Uuid::createRandom(),
*libCmp, cmp->libVariantUuid, name));
copy->setValue(cmp->value);
copy->setAttributes(cmp->attributes);
ComponentAssemblyOptionList assemblyOptions = cmp->assemblyOptions;
for (ComponentAssemblyOption& option : assemblyOptions) {
option.setAssemblyVariants(
convertAssemblyVariants(option.getAssemblyVariants()));
}
copy->setAssemblyOptions(assemblyOptions);
copy->setLockAssembly(cmp->lockAssembly);
componentInstanceMap.insert(cmp->uuid, copy->getUuid());
execNewChildCmd(
new CmdComponentInstanceAdd(mProject.getCircuit(), copy.release()));
}
// Paste symbols
QHash<Uuid, Uuid> symbolMap;
for (const SchematicClipboardData::SymbolInstance& sym :
mData->getSymbolInstances()) {
ComponentInstance* cmpInst =
mProject.getCircuit().getComponentInstanceByUuid(
componentInstanceMap.value(sym.componentInstanceUuid,
Uuid::createRandom()));
if (!cmpInst) throw LogicError(__FILE__, __LINE__);
std::unique_ptr<SI_Symbol> symbol(new SI_Symbol(
mSchematic, Uuid::createRandom(), *cmpInst, sym.symbolVariantItemUuid,
sym.position + mPosOffset, sym.rotation, sym.mirrored, false));
for (const Text& text : sym.texts) {
// Note: Keep the UUID since it acts as a reference to the original
// library symbol text.
Text copy(text);
copy.setPosition(copy.getPosition() + mPosOffset); // move
SI_Text* item = new SI_Text(mSchematic, copy);
symbol->addText(*item);
}
symbolMap.insert(sym.uuid, symbol->getUuid());
execNewChildCmd(new CmdSymbolInstanceAdd(*symbol));
if (auto item = mScene.getSymbols().value(symbol.release())) {
item->setSelected(true);
}
}
// Paste bus segments
QHash<Uuid, QHash<Uuid, SI_BusJunction*>> busJunctionsMap;
for (const SchematicClipboardData::BusSegment& seg :
mData->getBusSegments()) {
// If there is at least one label, we keep the bus name (reuse existing
// bus if it exists, or add a new one). Otherwise, create a new, auto-
// named bus.
std::shared_ptr<SchematicClipboardData::Bus> busObj =
mData->getBuses().get(seg.busUuid); // can throw
Bus* bus = nullptr;
if (!seg.labels.isEmpty()) {
bus = mProject.getCircuit().getBusByName(*busObj->name);
}
if (!bus) {
if (!seg.labels.isEmpty()) {
bus = new Bus(mProject.getCircuit(), Uuid::createRandom(), busObj->name,
false, busObj->prefixNetNames,
busObj->maxTraceLengthDifference);
} else {
bus = new Bus(mProject.getCircuit(), Uuid::createRandom(),
BusName(mProject.getCircuit().generateAutoBusName()),
true, false, std::nullopt);
}
execNewChildCmd(new CmdBusAdd(*bus));
}
Q_ASSERT(bus);
// Add new segment
SI_BusSegment* copy =
new SI_BusSegment(mSchematic, Uuid::createRandom(), *bus);
execNewChildCmd(new CmdSchematicBusSegmentAdd(*copy));
// Add junctions and lines
std::unique_ptr<CmdSchematicBusSegmentAddElements> cmdAddElements(
new CmdSchematicBusSegmentAddElements(*copy));
QHash<Uuid, SI_BusJunction*> junctionsMap;
for (const Junction& junction : seg.junctions) {
SI_BusJunction* newJunction =
cmdAddElements->addJunction(junction.getPosition() + mPosOffset);
junctionsMap.insert(junction.getUuid(), newJunction);
}
for (const NetLine& nl : seg.lines) {
const std::optional<Uuid> uuid1 = nl.getP1().tryGetJunction();
const std::optional<Uuid> uuid2 = nl.getP2().tryGetJunction();
if ((!uuid1) || (!uuid2)) {
throw LogicError(__FILE__, __LINE__);
}
SI_BusJunction* p1 = junctionsMap[*uuid1];
SI_BusJunction* p2 = junctionsMap[*uuid2];
if ((!p1) || (!p2)) {
throw LogicError(__FILE__, __LINE__);
}
cmdAddElements->addLine(*p1, *p2);
}
execNewChildCmd(cmdAddElements.release());
// Add labels
for (const NetLabel& label : seg.labels) {
SI_BusLabel* newLabel = new SI_BusLabel(
*copy,
NetLabel(Uuid::createRandom(), label.getPosition() + mPosOffset,
label.getRotation(), label.getMirrored()));
CmdSchematicBusLabelAdd* cmd = new CmdSchematicBusLabelAdd(*newLabel);
execNewChildCmd(cmd);
}
// Select pasted segment items.
foreach (SI_BusJunction* bj, copy->getJunctions()) {
if (auto item = mScene.getBusJunctions().value(bj)) {
item->setSelected(true);
}
}
foreach (SI_BusLine* line, copy->getLines()) {
if (auto item = mScene.getBusLines().value(line)) {
item->setSelected(true);
}
}
foreach (SI_BusLabel* label, copy->getLabels()) {
if (auto item = mScene.getBusLabels().value(label)) {
item->setSelected(true);
}
}
busJunctionsMap.insert(seg.uuid, junctionsMap);
}
// Paste net segments
for (const SchematicClipboardData::NetSegment& seg :
mData->getNetSegments()) {
// Get or add netclass with the name "default"
NetClass* netclass =
mProject.getCircuit().getNetClassByName(ElementName("default"));
if (!netclass) {
CmdNetClassAdd* cmd =
new CmdNetClassAdd(mProject.getCircuit(), ElementName("default"));
execNewChildCmd(cmd);
netclass = cmd->getNetClass();
Q_ASSERT(netclass);
}
// Add a new netsignal
CmdNetSignalAdd* cmdAddNetSignal =
new CmdNetSignalAdd(mProject.getCircuit(), *netclass);
execNewChildCmd(cmdAddNetSignal);
NetSignal* netSignal = cmdAddNetSignal->getNetSignal();
Q_ASSERT(netSignal);
std::optional<CircuitIdentifier> forcedNetName;
// Add new segment
SI_NetSegment* copy =
new SI_NetSegment(mSchematic, Uuid::createRandom(), *netSignal);
execNewChildCmd(new CmdSchematicNetSegmentAdd(*copy));
// Add netpoints and netlines
std::unique_ptr<CmdSchematicNetSegmentAddElements> cmdAddElements(
new CmdSchematicNetSegmentAddElements(*copy));
QHash<Uuid, SI_NetPoint*> netPointMap;
for (const Junction& junction : seg.junctions) {
SI_NetPoint* netpoint =
cmdAddElements->addNetPoint(junction.getPosition() + mPosOffset);
netPointMap.insert(junction.getUuid(), netpoint);
}
auto getAnchor = [&](const NetLineAnchor& a) -> SI_NetLineAnchor* {
if (std::optional<Uuid> obj = a.tryGetJunction()) {
return netPointMap[*obj];
} else if (std::optional<NetLineAnchor::BusAnchor> obj =
a.tryGetBusJunction()) {
return busJunctionsMap.value(obj->segment).value(obj->junction);
} else if (std::optional<NetLineAnchor::PinAnchor> obj = a.tryGetPin()) {
SI_Symbol* symbol = mSchematic.getSymbols().value(
symbolMap.value(obj->symbol, Uuid::createRandom()));
if (!symbol) return nullptr;
SI_SymbolPin* pin = symbol->getPin(obj->pin);
if (!pin) return nullptr;
ComponentSignalInstance& sigInst = pin->getComponentSignalInstance();
if (sigInst.getNetSignal() != netSignal) {
execNewChildCmd(new CmdCompSigInstSetNetSignal(sigInst, netSignal));
}
if (sigInst.isNetSignalNameForced() && (!forcedNetName)) {
forcedNetName = CircuitIdentifier(sigInst.getForcedNetSignalName());
}
return pin;
} else {
return nullptr;
}
};
for (const NetLine& nl : seg.lines) {
SI_NetLineAnchor* p1 = getAnchor(nl.getP1());
SI_NetLineAnchor* p2 = getAnchor(nl.getP2());
if ((!p1) || (!p2)) {
throw LogicError(__FILE__, __LINE__);
}
cmdAddElements->addNetLine(*p1, *p2);
}
execNewChildCmd(cmdAddElements.release());
// Add netlabels
for (const NetLabel& nl : seg.labels) {
SI_NetLabel* netLabel = new SI_NetLabel(
*copy,
NetLabel(Uuid::createRandom(), nl.getPosition() + mPosOffset,
nl.getRotation(), nl.getMirrored()));
CmdSchematicNetLabelAdd* cmd = new CmdSchematicNetLabelAdd(*netLabel);
execNewChildCmd(cmd);
if (!forcedNetName) {
// If the net segment has at least one net label, copy the original
// net name.
forcedNetName = seg.netName;
}
}
// If the net signal name is enforced, rename it or merge it with an
// existing net signal.
if (forcedNetName) {
if (NetSignal* ns =
mProject.getCircuit().getNetSignalByName(**forcedNetName)) {
// merge nets
execNewChildCmd(
new CmdChangeNetSignalOfSchematicNetSegment(*copy, *ns));
} else {
// rename net
CmdNetSignalEdit* cmd =
new CmdNetSignalEdit(mProject.getCircuit(), *netSignal);
cmd->setName(*forcedNetName, false);
execNewChildCmd(cmd);
}
}
// Select pasted net segment items.
foreach (SI_NetPoint* netPoint, copy->getNetPoints()) {
if (auto item = mScene.getNetPoints().value(netPoint)) {
item->setSelected(true);
}
}
foreach (SI_NetLine* netLine, copy->getNetLines()) {
if (auto item = mScene.getNetLines().value(netLine)) {
item->setSelected(true);
}
}
foreach (SI_NetLabel* netLabel, copy->getNetLabels()) {
if (auto item = mScene.getNetLabels().value(netLabel)) {
item->setSelected(true);
}
}
}
// Paste polygons
for (const Polygon& polygon : mData->getPolygons()) {
Polygon copy(Uuid::createRandom(), polygon); // assign new UUID
copy.setPath(copy.getPath().translated(mPosOffset)); // move
SI_Polygon* item = new SI_Polygon(mSchematic, copy);
execNewChildCmd(new CmdSchematicPolygonAdd(*item));
if (auto graphicsItem = mScene.getPolygons().value(item)) {
graphicsItem->setSelected(true);
}
}
// Paste texts
for (const Text& text : mData->getTexts()) {
Text copy(Uuid::createRandom(), text); // assign new UUID
copy.setPosition(copy.getPosition() + mPosOffset); // move
SI_Text* item = new SI_Text(mSchematic, copy);
execNewChildCmd(new CmdSchematicTextAdd(*item));
if (auto graphicsItem = mScene.getTexts().value(item)) {
graphicsItem->setSelected(true);
}
}
// Paste images
for (const Image& image : mData->getImages()) {
// If the chosen file already exists in the schematic, just reuse it to
// avoid data duplication. Otherwise, determine the name of the new
// file to be created.
const QByteArray data =
mData->getDirectory()->readIfExists(*image.getFileName());
if (data.isEmpty()) continue; // Skip images with missing file.
std::optional<FileProofName> fileName =
ImageHelpers::findExistingFile(mSchematic.getDirectory(), data);
const bool fileExists = fileName.has_value();
if (!fileName) {
fileName = ImageHelpers::getUnusedFileName(mSchematic.getDirectory(),
image.getFileBasename(),
image.getFileExtension());
}
Q_ASSERT(fileName);
Image copy(Uuid::createRandom(), image); // assign new UUID
copy.setPosition(copy.getPosition() + mPosOffset); // move
SI_Image* item = new SI_Image(mSchematic, copy);
execNewChildCmd(new CmdSchematicImageAdd(*item, mSchematic.getDirectory(),
fileExists ? QByteArray() : data));
if (auto graphicsItem = mScene.getImages().value(item)) {
graphicsItem->setSelected(true);
}
}
undoScopeGuard.dismiss(); // no undo required
return getChildCount() > 0;
}
/*******************************************************************************
* End of File
******************************************************************************/
} // namespace editor
} // namespace librepcb
0e185510cThis file is pinned to the selected release. Download the original to open it in your design tool.