/**
* Loads user/SCC information from the command line or INI file.
*/
void FSubversionSourceControlProvider::ParseCommandLineSettings(bool bForceConnection)
{
ISourceControlModule& SourceControlModule = FModuleManager::LoadModuleChecked<ISourceControlModule>( "SourceControl" );
FSubversionSourceControlModule& SubversionSourceControl = FModuleManager::GetModuleChecked<FSubversionSourceControlModule>( "SubversionSourceControl" );
bool bFoundCmdLineSettings = false;
// Check command line for any overridden settings
FString RepositoryName = SubversionSourceControl.AccessSettings().GetRepository();
FString UserName = SubversionSourceControl.AccessSettings().GetUserName();
FString Password;
bFoundCmdLineSettings = FParse::Value(FCommandLine::Get(), TEXT("SVNRepo="), RepositoryName);
bFoundCmdLineSettings |= FParse::Value(FCommandLine::Get(), TEXT("SVNUser="******"SVNPass="), Password);
// Command line settings get written to the global settings.
// These wont get saved if the build is unattended.
if(bFoundCmdLineSettings)
{
SubversionSourceControl.AccessSettings().SetRepository(RepositoryName);
SubversionSourceControl.AccessSettings().SetUserName(UserName);
}
if(bForceConnection && TestConnection(RepositoryName, UserName, Password))
{
bWorkingOffline = false;
}
//Save off settings so this doesn't happen every time (wont save if unattended)
SubversionSourceControl.SaveSettings();
}
void GTicketInternalClient::FlushTickets()
{
list<GTicketPtr>::iterator pos;
if(out.size()==0) return;
TestConnection();
if (IsConnection())
{
pos=find_if(out.begin(),out.end(),boost::bind(>icketInternalClient::FlushTicket,this,_1));
out.erase(out.begin(),pos);
Write();
}
DWORD64 now = GSERVER->CurrentSTime();
for (pos = out.begin(); pos != out.end(); )
{
if ((*pos)->send_deadline != 0 && (*pos)->send_deadline <= now)
{
if (dropped_ticket_callback)
{
dropped_ticket_callback(**pos, ETDR_DeadlineReached);
}
pos = out.erase(pos);
}
else
{
pos++;
}
}
}
/* Write now that connection is set */
static ZERO_OR_ERROR FS_w_given_bus(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if ( BAD(TestConnection(pn)) ) {
return -ECONNABORTED;
} else if (KnownBus(pn) && BusIsServer(pn->selected_connection)) {
return ServerWrite(owq);
} else if (OWQ_pn(owq).type == ePN_real) {
ZERO_OR_ERROR write_or_error = DeviceLockGet(pn);
if (write_or_error == 0) {
write_or_error = FS_w_local(owq);
DeviceLockRelease(pn);
} else {
LEVEL_DEBUG("Cannot lock device for writing") ;
}
return write_or_error ;
} else if ( IsInterfaceDir(pn) ) {
ZERO_OR_ERROR write_or_error;
BUSLOCK(pn);
write_or_error = FS_w_local(owq);
BUSUNLOCK(pn);
return write_or_error ;
} else {
return FS_w_local(owq);
}
}
/* Read real device (Non-virtual). Will repeat 3 times if needed */
static SIZE_OR_ERROR FS_read_real(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
SIZE_OR_ERROR read_or_error;
/* First try */
/* in and bus_nr already set */
read_or_error = FS_read_distribute(owq);
/* Second Try */
/* if not a specified bus, relook for chip location */
if (read_or_error < 0) { //error
STAT_ADD1(read_tries[1]);
if (SpecifiedBus(pn)) { // this bus or bust!
if ( BAD(TestConnection(pn)) ) {
read_or_error = -ECONNABORTED;
} else {
read_or_error = FS_read_distribute(owq); // 2nd try
if (read_or_error < 0) { // third try
STAT_ADD1(read_tries[2]);
read_or_error = FS_read_distribute(owq);
}
}
} else if (BusIsServer(pn->selected_connection)) {
int bus_nr = pn->selected_connection->index ; // current selected bus
INDEX_OR_ERROR busloc_or_error = ReCheckPresence(pn) ;
// special handling or remote
// only repeat if the bus number is wrong
// because the remote does the rereads
if ( bus_nr != busloc_or_error ) {
if (busloc_or_error < 0) {
read_or_error = -ENOENT;
} else {
read_or_error = FS_read_distribute(owq);
if (read_or_error < 0) { // third try
STAT_ADD1(read_tries[2]);
read_or_error = FS_read_distribute(owq);
}
}
}
} else {
INDEX_OR_ERROR busloc_or_error = ReCheckPresence(pn); // search again
if (busloc_or_error < 0) {
read_or_error = -ENOENT;
} else {
read_or_error = FS_read_distribute(owq);
if (read_or_error < 0) { // third try
STAT_ADD1(read_tries[2]);
read_or_error = FS_read_distribute(owq);
}
}
}
}
return read_or_error;
}
void
ConnectionCommunity::OnTestConnection(HWND hwnd)
{
UpdateWindow(hwnd);
if(GetActiveWin())
UpdateWindow(GetActiveWin()->m_pctabmodule->GetHwnd());
TestConnection(hwnd, wyTrue);
}
void NoiseRemoval::RemoveBadCriticalPoints()
{
m_center_cluster_mapping.clear(); m_badvtx_cluster_mapping.clear();
m_newAddSad.clear();
for(vector<NoiseCluster>::iterator it = m_NoiseCluster.begin(); it!=m_NoiseCluster.end(); ++it)
{
size_t numMaxPoints(0), numMinPoints(0), numSadPoints(0);
vector<size_t>& cluster = it->noisePoints;
vector<Global::POINTTYPE>& pointType = it->noiseType;
pointType.resize(cluster.size());
for(size_t k=0; k<cluster.size(); ++k)
{
size_t vid = cluster[k];
M_Point* mp = (*p_vtx)[vid];
Global::POINTTYPE type = mp->getType();
pointType[k] = type;
if(type == Global::MAXPOINT){
p_MaxPointID->erase( p_MaxPointID->find(vid)); numMaxPoints++;
}else if(type == Global::MINPOINT){
p_MinPointID->erase( p_MinPointID->find(vid)); numMinPoints++;
}else if(type == Global::SADDLEPOINT){
p_SadPointID->erase( p_SadPointID->find(vid)); numSadPoints++;
}
mp->setType(Global::REGULARPOINT);
}
size_t tmp_maxNum = max(numMaxPoints,max(numMinPoints,numSadPoints));
size_t& centerP = it->centerPoint;
if(numMaxPoints == tmp_maxNum){
it->type = Global::MAXPOINT;
centerP = FindCenterInCluster(*it, Global::MAXPOINT);
(*p_vtx)[centerP]->setType(Global::MAXPOINT); p_MaxPointID->insert(centerP);
}else if(numMinPoints == tmp_maxNum){
it->type = Global::MINPOINT;
centerP = FindCenterInCluster(*it, Global::MINPOINT);
(*p_vtx)[centerP]->setType(Global::MINPOINT); p_MinPointID->insert(centerP);
}else if(numSadPoints == tmp_maxNum){
it->type = Global::SADDLEPOINT;
centerP = FindCenterInCluster(*it, Global::SADDLEPOINT);
(*p_vtx)[centerP]->setType(Global::SADDLEPOINT); p_SadPointID->insert(centerP);
m_newAddSad.push_back(centerP);
}
m_center_cluster_mapping[centerP] = it-m_NoiseCluster.begin();
for(size_t k=0; k<cluster.size(); ++k)
{
m_badvtx_cluster_mapping[cluster[k]] = it-m_NoiseCluster.begin();
}
}
ModifyConnLine();
ModifyDualConnLine();
TestConnection();
}
/* Write to settings dir */
static ZERO_OR_ERROR FS_w_settings(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if ( BAD(TestConnection(pn)) ) {
// safe for connection_in == NULL
return -ECONNABORTED;
} else if (KnownBus(pn) && BusIsServer(pn->selected_connection)) {
return ServerWrite(owq);
} else if ( pn->selected_connection != NO_CONNECTION ) {
LEVEL_DEBUG("Attempt to write to local bus for /settings");
return -ENODEV ;
} else {
return FS_w_local(owq);
}
}
// Look on a given connection for the device
static INDEX_OR_ERROR CheckThisConnection(int bus_nr, struct parsedname *pn)
{
struct parsedname s_pn_copy;
struct parsedname * pn_copy = &s_pn_copy ;
struct connection_in * in = find_connection_in(bus_nr) ;
INDEX_OR_ERROR connection_result = INDEX_BAD ;
if ( in == NO_CONNECTION ) {
return INDEX_BAD ;
}
memcpy(pn_copy, pn, sizeof(struct parsedname)); // shallow copy
pn_copy->selected_connection = in;
if ( BAD( TestConnection(pn_copy) ) ) {
// Connection currently disconnected
return INDEX_BAD;
} else if (BusIsServer(in)) {
// Server
if ( INDEX_VALID( ServerPresence(pn_copy) ) ) {
connection_result = in->index;
}
} else if ( in->iroutines.flags & ADAP_FLAG_sham ) {
return INDEX_BAD ;
} else if ( in->iroutines.flags & ADAP_FLAG_presence_from_dirblob ) {
// local connection with a dirblob (like fake, mock, ...)
if ( GOOD( PresenceFromDirblob( pn_copy ) ) ) {
connection_result = in->index ;
}
} else {
// local connection but need to ask directly
struct transaction_log t[] = {
TRXN_NVERIFY,
TRXN_END,
};
if ( GOOD( BUS_transaction(t, pn_copy) ) ) {
connection_result = in->index ;
}
}
if ( connection_result == INDEX_BAD ) {
LEVEL_DEBUG("Presence of "SNformat" NOT found on bus %s",SNvar(pn_copy->sn),SAFESTRING(DEVICENAME(in))) ;
} else {
LEVEL_DEBUG("Presence of "SNformat" FOUND on bus %s",SNvar(pn_copy->sn),SAFESTRING(DEVICENAME(in))) ;
Cache_Add_Device(in->index,pn_copy->sn) ; // add or update cache */
}
return connection_result ;
}
void QmitkNPOptitrackWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()));
connect((QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()));
}
}
void QmitkTrackingDeviceConfigurationWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_trackingDeviceChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(TrackingDeviceChanged()) );
connect( (QObject*)(m_Controls->m_testConnectionPolaris), SIGNAL(clicked()), this, SLOT(TestConnection()) );
connect( (QObject*)(m_Controls->m_testConnectionAurora), SIGNAL(clicked()), this, SLOT(TestConnection()) );
connect( (QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()) );
connect( (QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()) );
connect( (QObject*)(m_Controls->m_resetButton), SIGNAL(clicked()), this, SLOT(ResetByUser()) );
connect( (QObject*)(m_Controls->m_finishedButton), SIGNAL(clicked()), this, SLOT(Finished()) );
connect( (QObject*)(m_Controls->m_AutoScanPolaris), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
connect( (QObject*)(m_Controls->m_AutoScanAurora), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
connect( (QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()) );
connect( (QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()) );
//slots for the worker thread
connect(m_ScanPortsWorker, SIGNAL(PortsScanned(int,int,QString,int,int)), this, SLOT(AutoScanPortsFinished(int,int,QString,int,int)) );
connect(m_TestConnectionWorker, SIGNAL(ConnectionTested(bool,QString)), this, SLOT(TestConnectionFinished(bool,QString)) );
connect(m_ScanPortsWorkerThread,SIGNAL(started()), m_ScanPortsWorker, SLOT(ScanPortsThreadFunc()) );
connect(m_TestConnectionWorkerThread,SIGNAL(started()), m_TestConnectionWorker, SLOT(TestConnectionThreadFunc()) );
//move the worker to the thread
m_ScanPortsWorker->moveToThread(m_ScanPortsWorkerThread);
m_TestConnectionWorker->moveToThread(m_TestConnectionWorkerThread);
//set a few UI components depending on Windows / Linux
#ifdef WIN32
m_Controls->portTypeLabelPolaris->setVisible(false);
m_Controls->portTypePolaris->setVisible(false);
m_Controls->portTypeLabelAurora->setVisible(false);
m_Controls->portTypeAurora->setVisible(false);
#else
m_Controls->comPortLabelAurora->setText("Port Nr:");
m_Controls->m_comPortLabelPolaris->setText("Port Nr:");
m_Controls->m_portSpinBoxAurora->setPrefix("");
m_Controls->m_portSpinBoxPolaris->setPrefix("");
#endif
//disable unused UI component
m_Controls->m_polarisTrackingModeBox->setVisible(false); //don't delete this component, because it is used in the MBI part of MITK
}
}
bool FPerforceConnection::EnsureValidConnection(FString& InOutServerName, FString& InOutUserName, FString& InOutWorkspaceName, const FPerforceConnectionInfo& InConnectionInfo)
{
bool bIsUnicodeServer = false;
bool bConnectionOK = false;
#if USE_P4_API
FMessageLog SourceControlLog("SourceControl");
FString NewServerName = InOutServerName;
FString NewUserName = InOutUserName;
FString NewClientSpecName = InOutWorkspaceName;
ClientApi TestP4;
TestP4.SetProtocol("tag", "");
TestP4.SetProtocol("enableStreams", "");
if (NewServerName.Len() && NewUserName.Len() && NewClientSpecName.Len())
{
//attempt connection with given settings
TestP4.SetPort(TCHAR_TO_ANSI(*NewServerName));
if(InConnectionInfo.Password.Len() > 0)
{
TestP4.SetPassword(TCHAR_TO_ANSI(*InConnectionInfo.Password));
}
if(InConnectionInfo.HostOverride.Len() > 0)
{
TestP4.SetHost(TCHAR_TO_ANSI(*InConnectionInfo.HostOverride));
}
}
Error P4Error;
TestP4.Init(&P4Error);
bConnectionOK = !P4Error.Test();
if (!bConnectionOK)
{
//Connection FAILED
StrBuf ErrorMessage;
P4Error.Fmt(&ErrorMessage);
SourceControlLog.Error(LOCTEXT("P4ErrorConnection", "P4ERROR: Failed to connect to source control provider."));
SourceControlLog.Error(FText::FromString(ANSI_TO_TCHAR(ErrorMessage.Text())));
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("PortName"), FText::FromString(NewServerName) );
Arguments.Add( TEXT("UserName"), FText::FromString(NewUserName) );
Arguments.Add( TEXT("ClientSpecName"), FText::FromString(NewClientSpecName) );
Arguments.Add( TEXT("Ticket"), FText::FromString(InConnectionInfo.Ticket) );
SourceControlLog.Error(FText::Format(LOCTEXT("P4ErrorConnection_Details", "Port={PortName}, User={UserName}, ClientSpec={ClientSpecName}, Ticket={Ticket}"), Arguments));
}
// run an info command to determine unicode status
if(bConnectionOK)
{
TArray<FText> ErrorMessages;
bConnectionOK = CheckUnicodeStatus(TestP4, bIsUnicodeServer, ErrorMessages);
if(!bConnectionOK)
{
SourceControlLog.Error(LOCTEXT("P4ErrorConnection", "P4ERROR: Could not determine server unicode status."));
SourceControlLog.Error(ErrorMessages.Num() > 0 ? ErrorMessages[0] : LOCTEXT("P4ErrorConnection_Unknown error", "Unknown error"));
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("PortName"), FText::FromString(NewServerName) );
Arguments.Add( TEXT("UserName"), FText::FromString(NewUserName) );
Arguments.Add( TEXT("ClientSpecName"), FText::FromString(NewClientSpecName) );
Arguments.Add( TEXT("Ticket"), FText::FromString(InConnectionInfo.Ticket) );
SourceControlLog.Error(FText::Format(LOCTEXT("P4ErrorConnection_Details", "Port={PortName}, User={UserName}, ClientSpec={ClientSpecName}, Ticket={Ticket}"), Arguments));
}
else
{
if(bIsUnicodeServer)
{
// set translation mode. From here onwards we need to use UTF8 when using text args
TestP4.SetTrans(CharSetApi::UTF_8);
}
// now we have determined unicode status, we can set the values that can be specified in non-ansi characters
TestP4.SetCwd(FROM_TCHAR(*FPaths::RootDir(), bIsUnicodeServer));
TestP4.SetUser(FROM_TCHAR(*NewUserName, bIsUnicodeServer));
TestP4.SetClient(FROM_TCHAR(*NewClientSpecName, bIsUnicodeServer));
if(InConnectionInfo.Ticket.Len())
{
TestP4.SetPassword(FROM_TCHAR(*InConnectionInfo.Ticket, bIsUnicodeServer));
}
}
}
if (bConnectionOK)
{
// If a client spec was not specified, attempt to auto-detect it here. If the detection is not successful, neither is this connection since we need a client spec.
if ( NewClientSpecName.IsEmpty() )
{
FPerforceConnectionInfo AutoCredentials = InConnectionInfo;
AutoCredentials.Port = TO_TCHAR(TestP4.GetPort().Text(), bIsUnicodeServer);
AutoCredentials.UserName = TO_TCHAR(TestP4.GetUser().Text(), bIsUnicodeServer);
bConnectionOK = FPerforceConnection::AutoDetectWorkspace(AutoCredentials, NewClientSpecName);
if ( bConnectionOK )
{
TestP4.SetClient(FROM_TCHAR(*NewClientSpecName, bIsUnicodeServer));
}
}
}
if (bConnectionOK)
{
TArray<FText> ErrorMessages;
bConnectionOK = TestConnection(TestP4, NewClientSpecName, bIsUnicodeServer, ErrorMessages);
if (!bConnectionOK)
{
//Login FAILED
SourceControlLog.Error(LOCTEXT("P4ErrorConnection", "P4ERROR: Failed to connect to source control provider."));
SourceControlLog.Error(ErrorMessages.Num() > 0 ? ErrorMessages[0] : LOCTEXT("P4ErrorConnection_InvalidWorkspace", "Invalid workspace"));
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("PortName"), FText::FromString(NewServerName) );
Arguments.Add( TEXT("UserName"), FText::FromString(NewUserName) );
Arguments.Add( TEXT("ClientSpecName"), FText::FromString(NewClientSpecName) );
Arguments.Add( TEXT("Ticket"), FText::FromString(InConnectionInfo.Ticket) );
SourceControlLog.Error(FText::Format(LOCTEXT("P4ErrorConnection_Details", "Port={PortName}, User={UserName}, ClientSpec={ClientSpecName}, Ticket={Ticket}"), Arguments));
}
}
//whether successful or not, disconnect to clean up
TestP4.Final(&P4Error);
if (bConnectionOK && P4Error.Test())
{
//Disconnect FAILED
bConnectionOK = false;
StrBuf ErrorMessage;
P4Error.Fmt(&ErrorMessage);
SourceControlLog.Error(LOCTEXT("P4ErrorFailedDisconnect", "P4ERROR: Failed to disconnect from Server."));
SourceControlLog.Error(FText::FromString(TO_TCHAR(ErrorMessage.Text(), bIsUnicodeServer)));
}
//if never specified, take the default connection values
if (NewServerName.Len() == 0)
{
NewServerName = TO_TCHAR(TestP4.GetPort().Text(), bIsUnicodeServer);
}
if (NewUserName.Len() == 0)
{
NewUserName = TO_TCHAR(TestP4.GetUser().Text(), bIsUnicodeServer);
}
if (NewClientSpecName.Len() == 0)
{
NewClientSpecName = TO_TCHAR(TestP4.GetClient().Text(), bIsUnicodeServer);
if (NewClientSpecName == TO_TCHAR(TestP4.GetHost().Text(), bIsUnicodeServer))
{
// If the client spec name is the same as host name, assume P4 couldn't get the actual
// spec name for this host and let GetPerforceLogin() try to find a proper one.
bConnectionOK = false;
}
}
if (bConnectionOK)
{
InOutServerName = NewServerName;
InOutUserName = NewUserName;
InOutWorkspaceName = NewClientSpecName;
}
#endif
return bConnectionOK;
}
void QmitkMicronTrackerWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()));
connect((QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()));
}
}
