int main( int argcount, char ** args )
{
// An instance of the script
// must be created before any other output.
// the last param automatically save files to the path
openLogin login;
filePicker picker(login,"sys/import","fileImportPick.cgi");
cgiScript script("text/html", false, picker.fileDir().c_str());
writelog("OK - script made");
// attempt to get cookie
if ( login.testLoginStatus() )
{
script.closeHeader();
writelog("Checking for files to delete");
picker.checkForfilesToDelete(script);
writelog("Generating file list");
picker.fileList(script);
writelog("Done");
}
else
{
script.Redirect("signIn.html");
script.closeHeader();
writelog("INVALID ACCESS ATTEMPT");
}
writelog("OK - All Done");
return(0);
}
void SELECTION_TOOL::select( BOARD_ITEM* aItem )
{
// Modules are treated in a special way - when they are selected, we have to mark
// all the parts that make the module as selected
if( aItem->Type() == PCB_MODULE_T )
{
MODULE* module = static_cast<MODULE*>( aItem );
module->RunOnChildren( boost::bind( &SELECTION_TOOL::selectVisually, this, _1 ) );
}
if( aItem->Type() == PCB_PAD_T )
{
MODULE* module = static_cast<MODULE*>( aItem->GetParent() );
if( m_selection.items.FindItem( module ) >= 0 )
return;
}
selectVisually( aItem );
ITEM_PICKER picker( aItem );
m_selection.items.PushItem( picker );
if( m_selection.Size() == 1 )
{
// Set as the current item, so the information about selection is displayed
m_frame->SetCurItem( aItem, true );
}
else if( m_selection.Size() == 2 ) // Check only for 2, so it will not be
{ // called for every next selected item
// If multiple items are selected, do not show the information about the selected item
m_frame->SetCurItem( NULL, true );
}
}
void LIB_EDIT_FRAME::copySelectedItems()
{
LIB_PART* part = GetCurPart();
if( !part )
return;
m_clipboard.ClearListAndDeleteItems(); // delete previous saved list, if exists
m_clipboard.SetLastCursorPosition( GetScreen()->m_BlockLocate.GetEnd() ); // store the reference point
for( LIB_ITEM& item : part->GetDrawItems() )
{
// We *do not* copy fields because they are unique for the whole component
// so skip them (do not duplicate) if they are flagged selected.
if( item.Type() == LIB_FIELD_T )
item.ClearFlags( SELECTED );
if( !item.IsSelected() )
continue;
// Do not clear the 'selected' flag. It is required to have items drawn when they are pasted.
LIB_ITEM* copy = (LIB_ITEM*) item.Clone();
copy->SetFlags( copy->GetFlags() | UR_TRANSIENT );
ITEM_PICKER picker( copy, UR_NEW );
m_clipboard.PushItem( picker );
}
}
// Assume this has been called with an
// application version selected.
void SoaWg::AddServiceVersionSlot() {
SoaRw *appVer = db.Tb("ApplicationVersion")->FocusRw();
if (appVer == 0)
return;
SoaRw *app = appVer->Ce("Application")->Row();
if (app == 0)
return;
DlgChooseAsset picker(this, app->Children("Service"), "Pick service");
if (picker.exec()) {
db.Tb("Service")->SetFocusedRwByViewId(picker.SelectedRow()->ViewId());
SoaTb *tb = db.Tb("ServiceVersion");
SoaRw *rw = tb->AllocRw(-1, true);
DlgNewAsset dlg(this, this, tb, rw);
if (dlg.exec()) {
tb->AddRw(dlg.Row());
RefreshViews();
}
else
delete rw;
}
}
void MapScene::addSector(const QVector<IndexedPosition>& points,
const QString& targetCompetition)
{
// Initialisation du secteur
SectorItem* newSector = new SectorItem(targetCompetition);
// Ajout de tous les points dans le secteur
foreach (const IndexedPosition& p, points)
newSector->append(IndexedPosition(p.x() * this->_amplificationRatio,
p.y() * -this->_amplificationRatio,
p.index()));
// Colorisation du secteur
ColorPicker picker(6);
QColor sectorColor(picker.color(this->_sectors.count(), 150));
newSector->setBrush(QBrush(sectorColor));
QPen pen(picker.dark(this->_sectors.count()));
pen.setJoinStyle(Qt::RoundJoin);
pen.setWidthF(1.5);
pen.setCosmetic(true);
newSector->setPen(pen);
newSector->setZValue(-1);
this->_sectors << newSector;
this->addItem(newSector);
}
/**
* Function SaveCopyOfZones
* creates a copy of zones having a given netcode on a given layer,
* and fill a pick list with pickers to handle these copies
* the UndoRedo status is set to UR_CHANGED for all items in list
* Later, UpdateCopyOfZonesList will change and update these pickers after a zone edition
* @param aPickList = the pick list
* @param aPcb = the Board
* @param aNetCode = the reference netcode. if aNetCode < 0 all netcodes are used
* @param aLayer = the layer of zones. if aLayer < 0, all layers are used
* @return the count of saved copies
*/
int SaveCopyOfZones( PICKED_ITEMS_LIST& aPickList, BOARD* aPcb, int aNetCode, LAYER_NUM aLayer )
{
int copyCount = 0;
for( unsigned ii = 0; ; ii++ )
{
ZONE_CONTAINER* zone = aPcb->GetArea( ii );
if( zone == NULL ) // End of list
break;
if( aNetCode >= 0 && aNetCode != zone->GetNetCode() )
continue;
if( aLayer >= 0 && aLayer != zone->GetLayer() )
continue;
ZONE_CONTAINER* zoneDup = new ZONE_CONTAINER( *zone );
zoneDup->SetParent( aPcb );
ITEM_PICKER picker( zone, UR_CHANGED );
picker.SetLink( zoneDup );
aPickList.PushItem( picker );
copyCount++;
}
return copyCount;
}
void StylePickerTool::mouseMove(const TPointD &pos, const TMouseEvent &e) {
if (!m_passivePick.getValue()) return;
/*--- PassiveにStyleを拾う機能 ---*/
PaletteController *controller =
TTool::getApplication()->getPaletteController();
TImageP image = getImage(false);
TToonzImageP ti = image;
TVectorImageP vi = image;
TXshSimpleLevel *level =
getApplication()->getCurrentLevel()->getSimpleLevel();
if ((!ti && !vi) || !level || !m_viewer->getGeometry().contains(pos)) {
controller->notifyStylePassivePicked(-1, -1, -1);
return;
}
int subsampling = level->getImageSubsampling(getCurrentFid());
StylePicker picker(image);
TPointD pickPos(TScale(1.0 / subsampling) * pos + TPointD(-0.5, -0.5));
int inkStyleId =
picker.pickStyleId(pickPos, getPixelSize() * getPixelSize(), 1);
int paintStyleId =
picker.pickStyleId(pickPos, getPixelSize() * getPixelSize(), 0);
int tone = picker.pickTone(pickPos);
controller->notifyStylePassivePicked(inkStyleId, paintStyleId, tone);
}
/*! rectangular rgb picking. The picked color will be an average of pixels in
* specified rectangle
*/
void ImageViewer::rectPickColor(bool putValueToStyleEditor) {
if (!m_isHistogramEnable) return;
if (!m_histogramPopup->isVisible()) return;
StylePicker picker(m_image);
TPoint startPos =
TPoint(m_pressedMousePos.x, height() - 1 - m_pressedMousePos.y);
TPoint endPos = TPoint(m_pos.x(), height() - 1 - m_pos.y());
TRectD area = TRectD(convert(startPos), convert(endPos));
area = area.enlarge(-1, -1);
if (area.getLx() < 2 || area.getLy() < 2) {
m_histogramPopup->updateAverageColor(TPixel32::Transparent);
return;
}
if (m_lutCalibrator && m_lutCalibrator->isValid() && m_fbo) m_fbo->bind();
const TPixel32 pix = picker.pickColor(area.enlarge(-1, -1));
if (m_lutCalibrator && m_lutCalibrator->isValid() && m_fbo) m_fbo->release();
// throw the picked color to the histogram
m_histogramPopup->updateAverageColor(pix);
// throw it to the style editor as well
if (putValueToStyleEditor) setPickedColorToStyleEditor(pix);
}
void PCB_EDIT_FRAME::Delete_Drawings_All_Layer( PCB_LAYER_ID aLayer )
{
if( IsCopperLayer( aLayer ) )
{
DisplayError( this, _( "Copper layer global delete not allowed!" ) );
return;
}
wxString msg;
msg.Printf( _( "Delete everything on layer %s?" ),
GetChars( GetBoard()->GetLayerName( aLayer ) ) );
if( !IsOK( this, msg ) )
return;
// Step 1: build the list of items to remove.
// because we are using iterators, we cannot modify the drawing list during iterate
// so we are using a 2 steps calculation:
// First, collect items.
// Second, remove items.
std::vector<BOARD_ITEM*> list;
for( auto item : GetBoard()->Drawings() )
{
switch( item->Type() )
{
case PCB_LINE_T:
case PCB_TEXT_T:
case PCB_DIMENSION_T:
case PCB_TARGET_T:
if( item->GetLayer() == aLayer )
list.push_back( item );
break;
default:
wxLogDebug( wxT( "Delete_Drawings_All_Layer() error: unknown type %d" ), item->Type() );
}
}
if( list.size() == 0 ) // No item found
return;
// Step 2: remove items from main list, and move them to the undo list
PICKED_ITEMS_LIST pickList;
ITEM_PICKER picker( NULL, UR_DELETED );
for( auto item : list )
{
item->UnLink();
picker.SetItem( item );
pickList.PushItem( picker );
}
OnModify();
SaveCopyInUndoList(pickList, UR_DELETED);
}
void PCB_EDIT_FRAME::Delete_Drawings_All_Layer( LAYER_ID aLayer )
{
if( IsCopperLayer( aLayer ) )
{
DisplayError( this, _( "Copper layer global delete not allowed!" ) );
return;
}
wxString msg = wxString::Format(
_( "Delete everything on layer %s?" ),
GetChars( GetBoard()->GetLayerName( aLayer ) ) );
if( !IsOK( this, msg ) )
return;
PICKED_ITEMS_LIST pickList;
ITEM_PICKER picker( NULL, UR_DELETED );
BOARD_ITEM* PtNext;
for( BOARD_ITEM* item = GetBoard()->m_Drawings; item; item = PtNext )
{
PtNext = item->Next();
switch( item->Type() )
{
case PCB_LINE_T:
case PCB_TEXT_T:
case PCB_DIMENSION_T:
case PCB_TARGET_T:
if( item->GetLayer() == aLayer )
{
item->UnLink();
picker.SetItem( item );
pickList.PushItem( picker );
}
break;
default:
{
wxString msg;
msg.Printf( wxT("Delete_Drawings_All_Layer() error: unknown type %d"),
item->Type() );
wxMessageBox( msg );
break;
}
}
}
if( pickList.GetCount() )
{
OnModify();
SaveCopyInUndoList(pickList, UR_DELETED);
}
}
void PCB_EDIT_FRAME::duplicateZone( wxDC* aDC, ZONE_CONTAINER* aZone )
{
ZONE_CONTAINER* newZone = new ZONE_CONTAINER( GetBoard() );
newZone->Copy( aZone );
newZone->UnFill();
ZONE_SETTINGS zoneSettings;
zoneSettings << *aZone;
bool success;
if( aZone->GetIsKeepout() )
success = InvokeKeepoutAreaEditor( this, &zoneSettings );
else if( aZone->IsOnCopperLayer() )
success = InvokeCopperZonesEditor( this, &zoneSettings );
else
success = InvokeNonCopperZonesEditor( this, aZone, &zoneSettings );
if( success )
{
zoneSettings.ExportSetting( *newZone );
newZone->m_Poly->Hatch();
s_AuxiliaryList.ClearListAndDeleteItems();
s_PickedList.ClearListAndDeleteItems();
SaveCopyOfZones( s_PickedList, GetBoard(), newZone->GetNet(), newZone->GetLayer() );
GetBoard()->Add( newZone );
ITEM_PICKER picker( newZone, UR_NEW );
s_PickedList.PushItem( picker );
GetScreen()->SetCurItem( NULL ); // This outline may be deleted when merging outlines
// Combine zones if possible
GetBoard()->OnAreaPolygonModified( &s_AuxiliaryList, newZone );
// Redraw zones
GetBoard()->RedrawAreasOutlines( m_canvas, aDC, GR_OR, newZone->GetLayer() );
GetBoard()->RedrawFilledAreas( m_canvas, aDC, GR_OR, newZone->GetLayer() );
if( GetBoard()->GetAreaIndex( newZone ) >= 0
&& GetBoard()->Test_Drc_Areas_Outlines_To_Areas_Outlines( newZone, true ) )
{
DisplayError( this, _( "Duplicate Zone: The outline of the duplicated zone fails DRC check!" ) );
}
UpdateCopyOfZonesList( s_PickedList, s_AuxiliaryList, GetBoard() );
SaveCopyInUndoList( s_PickedList, UR_UNSPECIFIED );
s_PickedList.ClearItemsList();
OnModify();
}
else
delete newZone;
}
ScreenCalibrator::PickResult ScreenCalibrator::pickPoint(const Ray& queryRay) const
{
/* Create a ray picker: */
Geometry::RayPicker<Scalar,3> picker(queryRay,Scalar(Vrui::getRayPickCosine()));
/* Process all points: */
for(PointList::const_iterator pIt=trackingPoints.begin();pIt!=trackingPoints.end();++pIt)
picker(*pIt);
for(PointList::const_iterator pIt=floorPoints.begin();pIt!=floorPoints.end();++pIt)
picker(*pIt);
for(PointList::const_iterator pIt=screenPoints.begin();pIt!=screenPoints.end();++pIt)
picker(*pIt);
for(PointList::const_iterator pIt=ballPoints.begin();pIt!=ballPoints.end();++pIt)
picker(*pIt);
/* Return the index of the picked point: */
if(picker.havePickedPoint())
return picker.getPickIndex();
else
return ~PickResult(0);
}
void PlotClusters(cv::Mat &dataset, const int *const medoids, const int *const assignment, int nData, int nMedoids)
{
float minx = std::numeric_limits<float>::max();
float miny = std::numeric_limits<float>::max();
float maxx = 0;
float maxy = 0;
for(int i=0; i < dataset.rows; i++)
{
cv::Mat tmp = dataset.row(i);
if(tmp.at<float>(0,0) < minx)
minx = tmp.at<float>(0,0);
if(tmp.at<float>(0,0) > maxx)
maxx = tmp.at<float>(0,0);
if(tmp.at<float>(0,1) < miny)
miny = tmp.at<float>(0,1);
if(tmp.at<float>(0,1) > maxy)
maxy = tmp.at<float>(0,1);
}
float xdim = maxx - minx;
float ydim = maxy - miny;
Eigen::MatrixXd colors(nMedoids,3);
ColorPicker picker(nMedoids);
cv::Mat img = cv::Mat::ones(1024,1024,CV_8UC3);
for(int i=0; i < dataset.rows-1; i++)
{
cv::Mat tmp = dataset.row(i);
float x = ((tmp.at<float>(0,0) - minx)/xdim)*1024;
float y = ((tmp.at<float>(0,1) - miny)/ydim)*1024;
cv::Point2f a(x,y);
Color c = picker.getColor(assignment[i]);
cv::circle(img, a, 2, cv::Scalar(c.r_,c.g_,c.b_), -1 );
}
for(int i=0; i < nMedoids; i++)
{
int center_ind = medoids[i];
cv::Mat tmp = dataset.row(medoids[i]);
float x = ((tmp.at<float>(0,0) - minx)/xdim)*1024;
float y = ((tmp.at<float>(0,1) - miny)/ydim)*1024;
cv::Point2f a(x,y);
Color c = picker.getColor(assignment[medoids[i]]);
cv::circle(img, a, 10, cv::Scalar(c.r_,c.g_,c.b_), -1 );
}
cv::imwrite("Clusters.jpg", img);
// cv::imshow("Clusters",img);
// cv::waitKey(0);
}
int main( int argcount, char ** args )
{
// DBG
// cout << "\r\n\r\n\r\n" << endl;
// the last param automatically save files to the path
char * ppi = getenv("PATH_INFO"); // where we were invoked
ocString path;
if( ppi ) path = ppi;
// DBG
// cout << " path " << path << endl;
Session_Obj session;
if( path.length() )
{
session.SetData( "LAST_PATH_INFO",path);
session.Synch();
}
else
{
path = session( "LAST_PATH_INFO" );
}
if( path.length() && path[0] == '/' )
{
path = path.substr(1);
}
openLogin login;
filePicker picker(login,path);
cgiScript script("text/html", false, picker.fileDir().c_str());
// attempt to get cookie
if ( login.testLoginStatus() )
{
script.closeHeader();
picker.checkForfilesToDelete(script);
picker.fileList(script);
// DBG
script << picker.debug << endl;
}
else
{
script.closeHeader();
script << "<html><body>" << endl;
script << "Not Logged in <!--";
script << login.getLastError() << endl;
script << " --></body></html>" << endl;
writelog("INVALID ACCESS ATTEMPT - FILE PICK SIGN IN REQUIRED!");
}
writelog("OK - All Done");
return(0);
}
void SCH_EDIT_FRAME::DeleteItem( SCH_ITEM* aItem, bool aAppend )
{
wxCHECK_RET( aItem != NULL, wxT( "Cannot delete invalid item." ) );
wxCHECK_RET( !( aItem->GetFlags() & STRUCT_DELETED ),
wxT( "Cannot delete item that is already deleted." ) );
// Here, aItem is not null.
SCH_SCREEN* screen = GetScreen();
if( aItem->Type() == SCH_SHEET_PIN_T )
{
// This item is attached to a node, and is not accessible by the global list directly.
SCH_SHEET* sheet = (SCH_SHEET*) aItem->GetParent();
wxCHECK_RET( (sheet != NULL) && (sheet->Type() == SCH_SHEET_T),
wxT( "Sheet label has invalid parent item." ) );
SaveCopyInUndoList( (SCH_ITEM*) sheet, UR_CHANGED, aAppend );
sheet->RemovePin( (SCH_SHEET_PIN*) aItem );
m_canvas->RefreshDrawingRect( sheet->GetBoundingBox() );
}
else
{
PICKED_ITEMS_LIST itemsList;
ITEM_PICKER picker( aItem, UR_DELETED );
aItem->SetFlags( STRUCT_DELETED );
itemsList.PushItem( picker );
screen->Remove( aItem );
if( aItem->IsConnectable() && aItem->Type() != SCH_JUNCTION_T )
{
std::vector< wxPoint > pts;
aItem->GetConnectionPoints( pts );
for( auto point : pts )
{
SCH_ITEM* junction;
if( !screen->IsJunctionNeeded( point )
&& ( junction = screen->GetItem( point, 0, SCH_JUNCTION_T ) ) )
{
ITEM_PICKER picker_juction( junction, UR_DELETED );
junction->SetFlags( STRUCT_DELETED );
itemsList.PushItem( picker_juction );
screen->Remove( junction );
}
}
}
SaveCopyInUndoList( itemsList, UR_DELETED, aAppend );
m_canvas->RefreshDrawingRect( aItem->GetBoundingBox() );
}
}
void
ColorButton::clicked()
{
// Color picker dialog
QColorDialog picker(this);
picker.setCurrentColor(color);
QColor rcolor = picker.getColor(color, this, tr("Choose Color"), QColorDialog::DontUseNativeDialog);
// if we got a good color use it and notify others
if (rcolor.isValid()) {
setColor(rcolor);
colorChosen(color);
}
}
/**
* Function AddArea
* Add an empty copper area to board areas list
* @param aNewZonesList = a PICKED_ITEMS_LIST * where to store new areas pickers (useful
* in undo commands) can be NULL
* @param aNetcode = the necode of the copper area (0 = no net)
* @param aLayer = the layer of area
* @param aStartPointPosition = position of the first point of the polygon outline of this area
* @param aHatch = hacth option
* @return pointer to the new area
*/
ZONE_CONTAINER* BOARD::AddArea( PICKED_ITEMS_LIST* aNewZonesList, int aNetcode,
int aLayer, wxPoint aStartPointPosition, int aHatch )
{
ZONE_CONTAINER* new_area = InsertArea( aNetcode,
m_ZoneDescriptorList.size( ) - 1,
aLayer, aStartPointPosition.x,
aStartPointPosition.y, aHatch );
if( aNewZonesList )
{
ITEM_PICKER picker( new_area, UR_NEW );
aNewZonesList->PushItem( picker );
}
return new_area;
}
/**
* Function RemoveArea
* remove copper area from net, and put it in a deleted list (if exists)
* @param aDeletedList = a PICKED_ITEMS_LIST * where to store deleted areas (useful in undo
* commands) can be NULL
* @param area_to_remove = area to delete or put in deleted list
*/
void BOARD::RemoveArea( PICKED_ITEMS_LIST* aDeletedList, ZONE_CONTAINER* area_to_remove )
{
if( area_to_remove == NULL )
return;
if( aDeletedList )
{
ITEM_PICKER picker( area_to_remove, UR_DELETED );
aDeletedList->PushItem( picker );
Remove( area_to_remove ); // remove from zone list, but does not delete it
}
else
{
Delete( area_to_remove );
}
}
unsigned int
ScaleTool::getAxisPick() const
{
unsigned int pick = Picker::NO_PICK;
if ( m_active ) {
m_panel->m_viewport->loadPickMatrices( UserInput::mousePos(), 1.f );
Picker picker( 4 );
for ( unsigned int i = 0; i < 3; ++i ) {
picker.setObjectIndex( i );
renderAxis( i );
}
picker.setObjectIndex( 3 );
renderCenter();
pick = picker.getPick();
m_panel->m_viewport->popMatrices();
}
return pick;
}
component::collision::BodyPicked PickHandler::findCollisionUsingBruteForce(const defaulttype::Vector3& origin,
const defaulttype::Vector3& direction,
double maxLength, core::objectmodel::BaseNode* rootNode)
{
BodyPicked result;
// Look for particles hit by this ray
// msg_info()<<"PickHandler::findCollisionUsingBruteForce" << std::endl;
simulation::MechanicalPickParticlesVisitor picker(sofa::core::ExecParams::defaultInstance(), origin, direction, maxLength, 0 );
//core::objectmodel::BaseNode* rootNode = mouseNode->getRoot(); //sofa::simulation::getSimulation()->getContext()->toBaseNode();
if (rootNode) picker.execute(rootNode->getContext());
else
dmsg_error("PickHandler") << "Root node not found.";
picker.getClosestParticle( result.mstate, result.indexCollisionElement, result.point, result.rayLength );
return result;
}
TableIndex *TableIndexFactory::getInstance(const TableIndexScheme &scheme) {
int colCount = (int)scheme.columnIndices.size();
TupleSchema *tupleSchema = scheme.tupleSchema;
assert(tupleSchema);
std::vector<ValueType> keyColumnTypes;
std::vector<int32_t> keyColumnLengths;
std::vector<bool> keyColumnAllowNull(colCount, true);
for (int i = 0; i < colCount; ++i) {
keyColumnTypes.push_back(tupleSchema->columnType(scheme.columnIndices[i]));
keyColumnLengths.push_back(tupleSchema->columnLength(scheme.columnIndices[i]));
}
TupleSchema *keySchema = TupleSchema::createTupleSchema(keyColumnTypes, keyColumnLengths, keyColumnAllowNull, true);
assert(keySchema);
VOLT_TRACE("Creating index for %s.\n%s", scheme.name.c_str(), keySchema->debug().c_str());
TableIndexPicker picker(keySchema, scheme);
TableIndex *retval = picker.getInstance();
return retval;
}
void SCH_EDIT_FRAME::PasteListOfItems( wxDC* DC )
{
SCH_ITEM* Struct;
if( m_blockItems.GetCount() == 0 )
{
DisplayError( this, wxT( "No struct to paste" ) );
return;
}
PICKED_ITEMS_LIST picklist;
for( unsigned ii = 0; ii < m_blockItems.GetCount(); ii++ )
{
Struct = DuplicateStruct( (SCH_ITEM*) m_blockItems.m_ItemsSelection.GetPickedItem( ii ) );
// Creates data, and push it as new data in undo item list buffer
ITEM_PICKER picker( Struct, UR_NEW );
picklist.PushItem( picker );
// Clear annotation and init new time stamp for the new components:
if( Struct->Type() == SCH_COMPONENT_T )
{
( (SCH_COMPONENT*) Struct )->SetTimeStamp( GetNewTimeStamp() );
( (SCH_COMPONENT*) Struct )->ClearAnnotation( NULL );
}
SetSchItemParent( Struct, GetScreen() );
Struct->Draw( m_canvas, DC, wxPoint( 0, 0 ), GR_DEFAULT_DRAWMODE );
GetScreen()->Append( Struct );
}
SaveCopyInUndoList( picklist, UR_NEW );
MoveItemsInList( picklist, GetScreen()->m_BlockLocate.m_MoveVector );
// Clear flags for all items.
GetScreen()->ClearDrawingState();
OnModify();
return;
}
void PCB_EDIT_FRAME::Block_Duplicate( bool aIncrement )
{
wxPoint MoveVector = GetScreen()->m_BlockLocate.GetMoveVector();
OnModify();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
PICKED_ITEMS_LIST newList;
newList.m_Status = UR_NEW;
ITEM_PICKER picker( NULL, UR_NEW );
BOARD_ITEM* newitem;
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
newitem = (BOARD_ITEM*)item->Clone();
if( aIncrement )
newitem->IncrementItemReference();
if( item->Type() == PCB_MODULE_T )
m_Pcb->m_Status_Pcb = 0;
m_Pcb->Add( newitem );
if( newitem )
{
newitem->Move( MoveVector );
picker.SetItem ( newitem );
newList.PushItem( picker );
}
}
if( newList.GetCount() )
SaveCopyInUndoList( newList, UR_NEW );
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QMap<int, QString> symbolMap;
symbolMap.insert(132, QObject::tr("Data"));
symbolMap.insert(135, QObject::tr("Decision"));
symbolMap.insert(137, QObject::tr("Document"));
symbolMap.insert(138, QObject::tr("Manual Input"));
symbolMap.insert(139, QObject::tr("Manual Operation"));
symbolMap.insert(141, QObject::tr("On Page Reference"));
symbolMap.insert(142, QObject::tr("Predefined Process"));
symbolMap.insert(145, QObject::tr("Preparation"));
symbolMap.insert(150, QObject::tr("Printer"));
symbolMap.insert(152, QObject::tr("Process"));
FlowChartSymbolPicker picker(symbolMap);
picker.show();
return app.exec();
}
void PlotScene::addCurve(PlotCurve *curve)
{
// Create object used to color curve randomly
ColorPicker picker(8);
// Change the "pen" of each point and line of the curve
curve->setPen(picker.color(this->curves.size() % 8));
// Append the cuve to the scene
this->curves.append(curve);
this->addItem(curve);
// Apply the visibility options
curve->setPointsVisible(this->pointsVisible);
curve->setCurveVisible(this->curvesVisible);
// Create a label associated to the new curve
QLabel* curveLabel = new QLabel(this->widgetParent);
curveLabel->setVisible(this->curveLabelsVisible);
this->curveLabels.append(curveLabel);
//this->addWidget(curveLabel);
}
/*! rgb picking
*/
void ImageViewer::pickColor(QMouseEvent *event, bool putValueToStyleEditor) {
if (!m_isHistogramEnable) return;
if (!m_histogramPopup->isVisible()) return;
QPoint curPos = event->pos() * getDevPixRatio();
// avoid to pick outside of the flip
if ((!m_image) || !rect().contains(curPos)) {
// throw transparent color
m_histogramPopup->updateInfo(TPixel32::Transparent, TPointD(-1, -1));
return;
}
StylePicker picker(m_image);
TPoint mousePos = TPoint(curPos.x(), height() - 1 - curPos.y());
TRectD area = TRectD(mousePos.x, mousePos.y, mousePos.x, mousePos.y);
if (m_lutCalibrator && m_lutCalibrator->isValid()) m_fbo->bind();
const TPixel32 pix = picker.pickColor(area);
if (m_lutCalibrator && m_lutCalibrator->isValid()) m_fbo->release();
QPoint viewP = mapFrom(this, curPos);
TPointD pos = getViewAff().inv() *
TPointD(viewP.x() - width() / 2, -viewP.y() + height() / 2);
TPointD imagePos = TPointD(0.5 * m_image->getBBox().getLx() + pos.x,
0.5 * m_image->getBBox().getLy() + pos.y);
if (m_image->getBBox().contains(imagePos)) {
// throw the picked color to the histogram
m_histogramPopup->updateInfo(pix, imagePos);
// throw it to the style editor as well
if (putValueToStyleEditor) setPickedColorToStyleEditor(pix);
} else {
// throw transparent color if picking outside of the image
m_histogramPopup->updateInfo(TPixel32::Transparent, TPointD(-1, -1));
}
}
void PCB_EDIT_FRAME::Start_DragTrackSegmentAndKeepSlope( TRACK* track, wxDC* DC )
{
TRACK* TrackToStartPoint = NULL;
TRACK* TrackToEndPoint = NULL;
bool error = false;
if( !track )
return;
// TODO: Use clenup functions to merge collinear segments if track
// is connected to a collinear segment.
s_StartSegmentPresent = s_EndSegmentPresent = true;
if( ( track->start == NULL ) || ( track->start->Type() == PCB_TRACE_T ) )
TrackToStartPoint = track->GetTrack( GetBoard()->m_Track, NULL, ENDPOINT_START, true, false );
// Test if more than one segment is connected to this point
if( TrackToStartPoint )
{
TrackToStartPoint->SetState( BUSY, true );
if( ( TrackToStartPoint->Type() == PCB_VIA_T )
|| track->GetTrack( GetBoard()->m_Track, NULL, ENDPOINT_START, true, false ) )
error = true;
TrackToStartPoint->SetState( BUSY, false );
}
if( ( track->end == NULL ) || ( track->end->Type() == PCB_TRACE_T ) )
TrackToEndPoint = track->GetTrack( GetBoard()->m_Track, NULL, ENDPOINT_END, true, false );
// Test if more than one segment is connected to this point
if( TrackToEndPoint )
{
TrackToEndPoint->SetState( BUSY, true );
if( (TrackToEndPoint->Type() == PCB_VIA_T)
|| track->GetTrack( GetBoard()->m_Track, NULL, ENDPOINT_END, true, false ) )
error = true;
TrackToEndPoint->SetState( BUSY, false );
}
if( error )
{
DisplayError( this,
_( "Unable to drag this segment: too many segments connected" ) );
return;
}
if( !TrackToStartPoint || ( TrackToStartPoint->Type() != PCB_TRACE_T ) )
s_StartSegmentPresent = false;
if( !TrackToEndPoint || ( TrackToEndPoint->Type() != PCB_TRACE_T ) )
s_EndSegmentPresent = false;
// Change high light net: the new one will be highlighted
GetBoard()->PushHighLight();
if( GetBoard()->IsHighLightNetON() )
HighLight( DC );
EraseDragList();
track->SetFlags( IS_DRAGGED );
if( TrackToStartPoint )
{
STATUS_FLAGS flag = STARTPOINT;
if( track->GetStart() != TrackToStartPoint->GetStart() )
flag = ENDPOINT;
AddSegmentToDragList( flag, TrackToStartPoint );
track->SetFlags( STARTPOINT );
}
if( TrackToEndPoint )
{
STATUS_FLAGS flag = STARTPOINT;
if( track->GetEnd() != TrackToEndPoint->GetStart() )
flag = ENDPOINT;
AddSegmentToDragList( flag, TrackToEndPoint );
track->SetFlags( ENDPOINT );
}
AddSegmentToDragList( track->GetFlags(), track );
UndrawAndMarkSegmentsToDrag( m_canvas, DC );
PosInit = GetCrossHairPosition();
s_LastPos = GetCrossHairPosition();
m_canvas->SetMouseCapture( Show_Drag_Track_Segment_With_Cte_Slope, Abort_MoveTrack );
GetBoard()->SetHighLightNet( track->GetNetCode() );
GetBoard()->HighLightON();
GetBoard()->DrawHighLight( m_canvas, DC, GetBoard()->GetHighLightNetCode() );
// Prepare the Undo command
ITEM_PICKER picker( NULL, UR_CHANGED );
for( unsigned ii = 0; ii < g_DragSegmentList.size(); ii++ )
{
TRACK* draggedtrack = g_DragSegmentList[ii].m_Track;
picker.SetItem( draggedtrack);
picker.SetLink ( draggedtrack->Clone() );
s_ItemsListPicker.PushItem( picker );
draggedtrack = (TRACK*) picker.GetLink();
draggedtrack->SetStatus( 0 );
draggedtrack->ClearFlags();
}
if( !InitialiseDragParameters() )
{
DisplayError( this, _( "Unable to drag this segment: two collinear segments" ) );
m_canvas->SetMouseCaptureCallback( NULL );
Abort_MoveTrack( m_canvas, DC );
return;
}
}
void PCB_EDIT_FRAME::StartMoveOneNodeOrSegment( TRACK* aTrack, wxDC* aDC, int aCommand )
{
if( !aTrack )
return;
EraseDragList();
// Change highlighted net: the new one will be highlighted
GetBoard()->PushHighLight();
if( GetBoard()->IsHighLightNetON() )
HighLight( aDC );
PosInit = GetCrossHairPosition();
if( aTrack->Type() == PCB_VIA_T )
{
aTrack->SetFlags( IS_DRAGGED | STARTPOINT | ENDPOINT );
AddSegmentToDragList( aTrack->GetFlags(), aTrack );
if( aCommand != ID_POPUP_PCB_MOVE_TRACK_SEGMENT )
{
Collect_TrackSegmentsToDrag( GetBoard(), aTrack->GetStart(),
aTrack->GetLayerSet(),
aTrack->GetNetCode(), aTrack->GetWidth() / 2 );
}
PosInit = aTrack->GetStart();
}
else
{
STATUS_FLAGS diag = aTrack->IsPointOnEnds( GetCrossHairPosition(), -1 );
wxPoint pos;
switch( aCommand )
{
case ID_POPUP_PCB_MOVE_TRACK_SEGMENT: // Move segment
aTrack->SetFlags( IS_DRAGGED | ENDPOINT | STARTPOINT );
AddSegmentToDragList( aTrack->GetFlags(), aTrack );
break;
case ID_POPUP_PCB_DRAG_TRACK_SEGMENT: // drag a segment
pos = aTrack->GetStart();
Collect_TrackSegmentsToDrag( GetBoard(), pos, aTrack->GetLayerSet(),
aTrack->GetNetCode(), aTrack->GetWidth() / 2 );
pos = aTrack->GetEnd();
aTrack->SetFlags( IS_DRAGGED | ENDPOINT | STARTPOINT );
Collect_TrackSegmentsToDrag( GetBoard(), pos, aTrack->GetLayerSet(),
aTrack->GetNetCode(), aTrack->GetWidth() / 2 );
break;
case ID_POPUP_PCB_MOVE_TRACK_NODE: // Drag via or move node
pos = (diag & STARTPOINT) ? aTrack->GetStart() : aTrack->GetEnd();
Collect_TrackSegmentsToDrag( GetBoard(), pos, aTrack->GetLayerSet(),
aTrack->GetNetCode(), aTrack->GetWidth() / 2 );
PosInit = pos;
break;
}
aTrack->SetFlags( IS_DRAGGED );
}
// Prepare the Undo command
ITEM_PICKER picker( aTrack, UR_CHANGED );
picker.SetLink( aTrack->Clone() );
s_ItemsListPicker.PushItem( picker );
for( unsigned ii = 0; ii < g_DragSegmentList.size(); ii++ )
{
TRACK* draggedtrack = g_DragSegmentList[ii].m_Track;
picker.SetItem( draggedtrack );
picker.SetLink( draggedtrack->Clone() );
s_ItemsListPicker.PushItem( picker );
draggedtrack = (TRACK*) picker.GetLink();
draggedtrack->SetStatus( 0 );
draggedtrack->ClearFlags();
}
s_LastPos = PosInit;
m_canvas->SetMouseCapture( Show_MoveNode, Abort_MoveTrack );
GetBoard()->SetHighLightNet( aTrack->GetNetCode() );
GetBoard()->HighLightON();
GetBoard()->DrawHighLight( m_canvas, aDC, GetBoard()->GetHighLightNetCode() );
m_canvas->CallMouseCapture( aDC, wxDefaultPosition, true );
UndrawAndMarkSegmentsToDrag( m_canvas, aDC );
}
void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
{
MODULE* currModule = NULL;
wxPoint PosOK;
wxPoint memopos;
int error;
LAYER_ID lay_tmp_TOP, lay_tmp_BOTTOM;
// Undo: init list
PICKED_ITEMS_LIST newList;
newList.m_Status = UR_CHANGED;
ITEM_PICKER picker( NULL, UR_CHANGED );
if( GetBoard()->m_Modules == NULL )
return;
m_canvas->SetAbortRequest( false );
switch( place_mode )
{
case PLACE_1_MODULE:
currModule = Module;
if( currModule == NULL )
return;
currModule->SetIsPlaced( false );
currModule->SetNeedsPlaced( false );
break;
case PLACE_OUT_OF_BOARD:
break;
case PLACE_ALL:
if( !IsOK( this, _( "Footprints NOT LOCKED will be moved" ) ) )
return;
break;
case PLACE_INCREMENTAL:
if( !IsOK( this, _( "Footprints NOT PLACED will be moved" ) ) )
return;
break;
}
memopos = CurrPosition;
lay_tmp_BOTTOM = g_Route_Layer_BOTTOM;
lay_tmp_TOP = g_Route_Layer_TOP;
RoutingMatrix.m_GridRouting = (int) GetScreen()->GetGridSize().x;
// Ensure Board.m_GridRouting has a reasonable value:
if( RoutingMatrix.m_GridRouting < Millimeter2iu( 0.25 ) )
RoutingMatrix.m_GridRouting = Millimeter2iu( 0.25 );
// Compute module parameters used in auto place
if( genPlacementRoutingMatrix( GetBoard(), m_messagePanel ) == 0 )
return;
int moduleCount = 0;
Module = GetBoard()->m_Modules;
for( ; Module != NULL; Module = Module->Next() )
{
Module->SetNeedsPlaced( false );
switch( place_mode )
{
case PLACE_1_MODULE:
if( currModule == Module )
{
// Module will be placed, add to undo.
picker.SetItem( currModule );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
}
break;
case PLACE_OUT_OF_BOARD:
Module->SetIsPlaced( false );
if( Module->IsLocked() )
break;
if( !RoutingMatrix.m_BrdBox.Contains( Module->GetPosition() ) )
{
// Module will be placed, add to undo.
picker.SetItem( Module );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
}
break;
case PLACE_ALL:
Module->SetIsPlaced( false );
if( Module->IsLocked() )
break;
// Module will be placed, add to undo.
picker.SetItem( Module );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
break;
case PLACE_INCREMENTAL:
if( Module->IsLocked() )
{
Module->SetIsPlaced( false );
break;
}
if( !Module->NeedsPlaced() )
{
// Module will be placed, add to undo.
picker.SetItem( Module );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
}
break;
}
if( Module->NeedsPlaced() ) // Erase from screen
{
moduleCount++;
Module->Draw( m_canvas, DC, GR_XOR );
}
else
{
genModuleOnRoutingMatrix( Module );
}
}
// Undo command: prepare list
if( newList.GetCount() )
SaveCopyInUndoList( newList, UR_CHANGED );
int cnt = 0;
wxString msg;
while( ( Module = PickModule( this, DC ) ) != NULL )
{
// Display some info about activity, module placement can take a while:
msg.Printf( _( "Place footprint %d of %d" ), cnt, moduleCount );
SetStatusText( msg );
double initialOrient = Module->GetOrientation();
// Display fill area of interest, barriers, penalties.
drawPlacementRoutingMatrix( GetBoard(), DC );
error = getOptimalModulePlacement( this, Module, DC );
double bestScore = MinCout;
double bestRotation = 0.0;
int rotAllowed;
PosOK = CurrPosition;
if( error == ESC )
goto end_of_tst;
// Try orientations 90, 180, 270 degrees from initial orientation
rotAllowed = Module->GetPlacementCost180();
if( rotAllowed != 0 )
{
Rotate_Module( DC, Module, 1800.0, true );
error = getOptimalModulePlacement( this, Module, DC );
MinCout *= OrientPenality[rotAllowed];
if( bestScore > MinCout ) // This orientation is better.
{
PosOK = CurrPosition;
bestScore = MinCout;
bestRotation = 1800.0;
}
else
{
Rotate_Module( DC, Module, initialOrient, false );
}
if( error == ESC )
goto end_of_tst;
}
// Determine if the best orientation of a module is 90.
rotAllowed = Module->GetPlacementCost90();
if( rotAllowed != 0 )
{
Rotate_Module( DC, Module, 900.0, true );
error = getOptimalModulePlacement( this, Module, DC );
MinCout *= OrientPenality[rotAllowed];
if( bestScore > MinCout ) // This orientation is better.
{
PosOK = CurrPosition;
bestScore = MinCout;
bestRotation = 900.0;
}
else
{
Rotate_Module( DC, Module, initialOrient, false );
}
if( error == ESC )
goto end_of_tst;
}
// Determine if the best orientation of a module is -90.
if( rotAllowed != 0 )
{
Rotate_Module( DC, Module, 2700.0, true );
error = getOptimalModulePlacement( this, Module, DC );
MinCout *= OrientPenality[rotAllowed];
if( bestScore > MinCout ) // This orientation is better.
{
PosOK = CurrPosition;
bestScore = MinCout;
bestRotation = 2700.0;
}
else
{
Rotate_Module( DC, Module, initialOrient, false );
}
if( error == ESC )
goto end_of_tst;
}
end_of_tst:
if( error == ESC )
break;
// Place module.
CurrPosition = GetCrossHairPosition();
SetCrossHairPosition( PosOK );
PlaceModule( Module, DC );
bestRotation += initialOrient;
if( bestRotation != Module->GetOrientation() )
Rotate_Module( DC, Module, bestRotation, false );
SetCrossHairPosition( CurrPosition );
Module->CalculateBoundingBox();
genModuleOnRoutingMatrix( Module );
Module->SetIsPlaced( true );
Module->SetNeedsPlaced( false );
}
CurrPosition = memopos;
RoutingMatrix.UnInitRoutingMatrix();
g_Route_Layer_TOP = lay_tmp_TOP;
g_Route_Layer_BOTTOM = lay_tmp_BOTTOM;
Module = GetBoard()->m_Modules;
for( ; Module != NULL; Module = Module->Next() )
{
Module->CalculateBoundingBox();
}
GetBoard()->m_Status_Pcb = 0;
Compile_Ratsnest( DC, true );
m_canvas->ReDraw( DC, true );
}
void PCB_EDIT_FRAME::Block_SelectItems()
{
LSET layerMask;
bool selectOnlyComplete = GetScreen()->m_BlockLocate.GetWidth() > 0 ;
GetScreen()->m_BlockLocate.Normalize();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
ITEM_PICKER picker( NULL, UR_UNSPECIFIED );
// Add modules
if( blockIncludeModules )
{
for( MODULE* module = m_Pcb->m_Modules; module; module = module->Next() )
{
LAYER_ID layer = module->GetLayer();
if( module->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete )
&& ( !module->IsLocked() || blockIncludeLockedModules ) )
{
if( blockIncludeItemsOnInvisibleLayers || m_Pcb->IsModuleLayerVisible( layer ) )
{
picker.SetItem ( module );
itemsList->PushItem( picker );
}
}
}
}
// Add tracks and vias
if( blockIncludeTracks )
{
for( TRACK* track = m_Pcb->m_Track; track != NULL; track = track->Next() )
{
if( track->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete ) )
{
if( blockIncludeItemsOnInvisibleLayers
|| m_Pcb->IsLayerVisible( track->GetLayer() ) )
{
picker.SetItem( track );
itemsList->PushItem( picker );
}
}
}
}
// Add graphic items
layerMask = LSET( Edge_Cuts );
if( blockIncludeItemsOnTechLayers )
layerMask.set();
if( !blockIncludeBoardOutlineLayer )
layerMask.set( Edge_Cuts, false );
for( BOARD_ITEM* PtStruct = m_Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
if( !m_Pcb->IsLayerVisible( PtStruct->GetLayer() ) && ! blockIncludeItemsOnInvisibleLayers)
continue;
bool select_me = false;
switch( PtStruct->Type() )
{
case PCB_LINE_T:
if( !layerMask[PtStruct->GetLayer()] )
break;
if( !PtStruct->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete ) )
break;
select_me = true; // This item is in bloc: select it
break;
case PCB_TEXT_T:
if( !blockIncludePcbTexts )
break;
if( !PtStruct->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete ) )
break;
select_me = true; // This item is in bloc: select it
break;
case PCB_TARGET_T:
if( !layerMask[PtStruct->GetLayer()] )
break;
if( !PtStruct->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete ) )
break;
select_me = true; // This item is in bloc: select it
break;
case PCB_DIMENSION_T:
if( !layerMask[PtStruct->GetLayer()] )
break;
if( !PtStruct->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete ) )
break;
select_me = true; // This item is in bloc: select it
break;
default:
break;
}
if( select_me )
{
picker.SetItem ( PtStruct );
itemsList->PushItem( picker );
}
}
// Add zones
if( blockIncludeZones )
{
for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
ZONE_CONTAINER* area = m_Pcb->GetArea( ii );
if( area->HitTest( GetScreen()->m_BlockLocate, selectOnlyComplete ) )
{
if( blockIncludeItemsOnInvisibleLayers
|| m_Pcb->IsLayerVisible( area->GetLayer() ) )
{
BOARD_ITEM* zone_c = (BOARD_ITEM*) area;
picker.SetItem ( zone_c );
itemsList->PushItem( picker );
}
}
}
}
}
