void GameMap::removeObject(TRect point)
{
TRect r;
TStringList * l = map.GetList("objects");
for (int i=0; i<l->Count; i++)
{
String name = l->Strings[i];
r.left = StrToInt(map.Get("objects."+name+".left"));
r.top = StrToInt(map.Get("objects."+name+".top"));
r.right = r.left+32;
r.bottom = r.top +32;
if (rectCollision(convertRect(r),convertRect(point)))
map.RemoveFromList("objects",l->Strings[i]);
}
delete l;
}
void
SplashUpdateScreenData(Splash * splash)
{
ImageRect srcRect, dstRect;
if (splash->currentFrame < 0) {
return;
}
initRect(&srcRect, 0, 0, splash->width, splash->height, 1,
splash->width * sizeof(rgbquad_t),
splash->frames[splash->currentFrame].bitmapBits, &splash->imageFormat);
if (splash->screenData) {
free(splash->screenData);
}
splash->screenStride = splash->width * splash->screenFormat.depthBytes;
if (splash->byteAlignment > 1) {
splash->screenStride =
(splash->screenStride + splash->byteAlignment - 1) &
~(splash->byteAlignment - 1);
}
splash->screenData = malloc(splash->height * splash->screenStride);
initRect(&dstRect, 0, 0, splash->width, splash->height, 1,
splash->screenStride, splash->screenData, &splash->screenFormat);
if (splash->overlayData) {
convertRect2(&srcRect, &dstRect, CVT_BLEND, &splash->overlayRect);
}
else {
convertRect(&srcRect, &dstRect, CVT_COPY);
}
}
QList<core::Connector::CollidingResult> core::Connector::collidingObjects(const QVector<RestrictedLineF *> &lines) const
{
QList<Connector::CollidingResult> result;
CollidingResult intersectionResult;
QList<QGraphicsItem*> items = removeIgnoredObjects(collidingItems(Qt::IntersectsItemShape));
// QList<QGraphicsItem*> items = removeIgnoredObjects(scene()->items());
QVector<RestrictedLineF*> rectLines;
QLineF::IntersectType intersection;
QPointF *intersectionPoint = new QPointF();
for(int l = 0; l < lines.size(); l++){
intersectionResult.line = lines[l];
intersectionResult.lineIndex = l;
for(int o = 0; o < items.size(); o++){
intersectionResult.objects.push_back((GraphicObject*)items[o]);
rectLines = convertRect(items[o]->boundingRect());
for(int rLine = 0; rLine < 4; rLine++){
intersection = lines[l]->intersect(*rectLines[rLine], intersectionPoint);
if(intersection == QLineF::BoundedIntersection){
intersectionResult.points.push_back(new QPointF(*intersectionPoint));
}
}
}
if(!intersectionResult.points.isEmpty()){
result.push_back(intersectionResult);
}
}
return result;
}
optional<LRESULT> TableViewImpl::processNotification(UINT message, UINT notification, WPARAM wParam, LPARAM lParam)
{
if( message == WM_NOTIFY ) {
switch(notification) {
case NM_CUSTOMDRAW: {
auto it = cbDrawItem.find(this);
if( it != cbDrawItem.end() ) {
auto lplvcd = reinterpret_cast<LPNMLVCUSTOMDRAW>(lParam);
NMCUSTOMDRAW & nmcd = lplvcd->nmcd;
switch(nmcd.dwDrawStage) {
case CDDS_PREPAINT:
return CDRF_NOTIFYITEMDRAW;
case CDDS_ITEMPREPAINT:
return CDRF_NOTIFYSUBITEMDRAW;
case CDDS_SUBITEM | CDDS_ITEMPREPAINT: {
CanvasImpl canvas(nmcd.hdc);
RECT winRect;
auto pRect = &winRect;
if( ListView_GetSubItemRect(hWnd,nmcd.dwItemSpec,lplvcd->iSubItem,LVIR_BOUNDS,pRect) == 0 ) {
log::error("ListView_GetSubItemRect error");
}
auto rect = convertRect(winRect);
bool itemWasDrawn = it->second(TableView::ItemPos{lplvcd->iSubItem,nmcd.dwItemSpec},canvas,rect);
if( itemWasDrawn ) return CDRF_SKIPDEFAULT;
} break;
}
}
} break;
case NM_CLICK: {
auto lpnmitem = reinterpret_cast<LPNMITEMACTIVATE>(lParam);
if( executeCallback(this,cbClickItem,TableView::ItemPos{lpnmitem->iSubItem,lpnmitem->iItem}) ) return 0;
} break;
}
}
return NativeControlImpl::processNotification(message,notification,wParam,lParam);
}
QString KicadSchematic2Svg::convert(const QString & filename, const QString & defName)
{
initLimits();
QFile file(filename);
if (!file.open(QFile::ReadOnly)) {
throw QObject::tr("unable to open %1").arg(filename);
}
QTextStream textStream(&file);
QString metadata = makeMetadata(filename, "schematic part", defName);
metadata += endMetadata();
QString reference;
int textOffset = 0;
bool drawPinNumber = true;
bool drawPinName = true;
bool gotDef = false;
while (true) {
QString line = textStream.readLine();
if (line.isNull()) {
break;
}
if (line.startsWith("DEF") && line.contains(defName, Qt::CaseInsensitive)) {
QStringList defs = splitLine(line);
if (defs.count() < 8) {
throw QObject::tr("bad schematic definition %1").arg(filename);
}
reference = defs[2];
textOffset = defs[4].toInt();
drawPinName = defs[6] == "Y";
drawPinNumber = defs[5] == "Y";
gotDef = true;
break;
}
}
if (!gotDef) {
throw QObject::tr("schematic part %1 not found in %2").arg(defName).arg(filename);
}
QString contents = "<g id='schematic'>\n";
bool inFPLIST = false;
while (true) {
QString fline = textStream.readLine();
if (fline.isNull()) {
throw QObject::tr("schematic %1 unexpectedly ends (1) in %2").arg(defName).arg(filename);
}
if (fline.contains("ENDDEF")) {
throw QObject::tr("schematic %1 unexpectedly ends (2) in %2").arg(defName).arg(filename);
}
if (fline.startsWith("DRAW")) {
break;
}
if (fline.startsWith("ALIAS")) continue;
if (fline.startsWith("F")) {
contents += convertField(fline);
continue;
}
if (fline.startsWith("$FPLIST")) {
inFPLIST = true;
break;
}
}
while (inFPLIST) {
QString fline = textStream.readLine();
if (fline.isNull()) {
throw QObject::tr("schematic %1 unexpectedly ends (1) in %2").arg(defName).arg(filename);
}
if (fline.startsWith("$ENDFPLIST")) {
inFPLIST = false;
break;
}
if (fline.contains("ENDDEF")) {
throw QObject::tr("schematic %1 unexpectedly ends (2) in %2").arg(defName).arg(filename);
}
}
int pinIndex = 0;
while (true) {
QString line = textStream.readLine();
if (line.isNull()) {
throw QObject::tr("schematic %1 unexpectedly ends (3) in %2").arg(defName).arg(filename);
}
if (line.startsWith("DRAW")) {
continue;
}
if (line.contains("ENDDEF")) {
break;
}
if (line.contains("ENDDRAW")) {
break;
}
if (line.startsWith("S")) {
contents += convertRect(line);
}
else if (line.startsWith("X")) {
// need to look at them all before formatting (I think)
contents += convertPin(line, textOffset, drawPinName, drawPinNumber, pinIndex++);
}
else if (line.startsWith("C")) {
contents += convertCircle(line);
}
else if (line.startsWith("P")) {
contents += convertPoly(line);
}
else if (line.startsWith("A")) {
contents += convertArc(line);
}
else if (line.startsWith("T")) {
contents += convertText(line);
}
else {
DebugDialog::debug("Unknown line " + line);
}
}
contents += "</g>\n";
QString svg = TextUtils::makeSVGHeader(GraphicsUtils::StandardFritzingDPI, GraphicsUtils::StandardFritzingDPI, m_maxX - m_minX, m_maxY - m_minY)
+ m_title + m_description + metadata + offsetMin(contents) + "</svg>";
return svg;
}
int
SplashDecodePng(Splash * splash, png_rw_ptr read_func, void *io_ptr)
{
int stride;
ImageFormat srcFormat;
png_uint_32 i, rowbytes;
png_bytepp row_pointers = NULL;
png_bytep image_data = NULL;
int success = 0;
double gamma;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
png_uint_32 width, height;
int bit_depth, color_type;
ImageRect srcRect, dstRect;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
goto done;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
goto done;
}
if (setjmp(png_ptr->jmpbuf)) {
goto done;
}
png_ptr->io_ptr = io_ptr;
png_ptr->read_data_fn = read_func;
png_set_sig_bytes(png_ptr, SIG_BYTES); /* we already read the 8 signature bytes */
png_read_info(png_ptr, info_ptr); /* read all PNG info up to image data */
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
NULL, NULL, NULL);
/* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
* transparency chunks to full alpha channel; strip 16-bit-per-sample
* images to 8 bits per sample; and convert grayscale to RGB[A]
* this may be sub-optimal but this simplifies implementation */
png_set_expand(png_ptr);
png_set_tRNS_to_alpha(png_ptr);
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
png_set_strip_16(png_ptr);
png_set_gray_to_rgb(png_ptr);
if (png_get_gAMA(png_ptr, info_ptr, &gamma))
png_set_gamma(png_ptr, 2.2, gamma);
png_read_update_info(png_ptr, info_ptr);
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
if (!SAFE_TO_ALLOC(rowbytes, height)) {
goto done;
}
if ((image_data = (unsigned char *) malloc(rowbytes * height)) == NULL) {
goto done;
}
if (!SAFE_TO_ALLOC(height, sizeof(png_bytep))) {
goto done;
}
if ((row_pointers = (png_bytepp) malloc(height * sizeof(png_bytep)))
== NULL) {
goto done;
}
for (i = 0; i < height; ++i)
row_pointers[i] = image_data + i * rowbytes;
png_read_image(png_ptr, row_pointers);
SplashCleanup(splash);
splash->width = width;
splash->height = height;
if (!SAFE_TO_ALLOC(splash->width, splash->imageFormat.depthBytes)) {
goto done;
}
stride = splash->width * splash->imageFormat.depthBytes;
if (!SAFE_TO_ALLOC(splash->height, stride)) {
goto done;
}
splash->frameCount = 1;
splash->frames = (SplashImage *)
malloc(sizeof(SplashImage) * splash->frameCount);
if (splash->frames == NULL) {
goto done;
}
splash->loopCount = 1;
splash->frames[0].bitmapBits = malloc(stride * splash->height);
if (splash->frames[0].bitmapBits == NULL) {
free(splash->frames);
goto done;
}
splash->frames[0].delay = 0;
/* FIXME: sort out the real format */
initFormat(&srcFormat, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
srcFormat.byteOrder = BYTE_ORDER_MSBFIRST;
initRect(&srcRect, 0, 0, width, height, 1, rowbytes,
image_data, &srcFormat);
initRect(&dstRect, 0, 0, width, height, 1, stride,
splash->frames[0].bitmapBits, &splash->imageFormat);
convertRect(&srcRect, &dstRect, CVT_COPY);
SplashInitFrameShape(splash, 0);
png_read_end(png_ptr, NULL);
success = 1;
done:
free(row_pointers);
free(image_data);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return success;
}
