void Application::onMessage( const FIX50SP2::ApplicationMessageRequest& message,
const FIX::SessionID& sessionID )
{
FIX50SP2::ExecutionReport executionReport;
try
{
FIX::Session *pSession = FIX::Session::lookupSession(sessionID);
FIX::UtcTimeStamp startTime;
std::cout << "Session( " << sessionID << ").onMessage ( order): "
<< " PossibleLongCallback= " << pSession->getPossibleBusyWaitInCalbacks() << std::endl;
std::cout << "Start time = " << FIX::UtcTimeStampConvertor::convert(startTime, true) << std::endl;
while (!timedOut(startTime, m_expectedDownloadLatency)) {
usleep(500000);
executionReport.set( FIX::ExecID(genExecID()) );
FIX::Session::sendToTarget( executionReport, sessionID );
}
FIX::UtcTimeStamp endTime;
std::cout << "End time = " << FIX::UtcTimeStampConvertor::convert(endTime, true) << std::endl;
}
catch ( std::exception& ex) {
std::cout << "ApplicationMessageRequest handling failed: " << ex.what() << std::endl;
}
}
bool Ipc::connect(enum Result code, const QObject *reciever, const char *member)
{
bool connected = false;
switch (code)
{
case ResultOk:
connected = QObject::connect(this, SIGNAL(ok(QByteArray)), reciever, member);
break;
case ResultNotImplemented:
connected = QObject::connect(this, SIGNAL(notImplemented()), reciever, member);
break;
case ResultFail:
connected = QObject::connect(this, SIGNAL(fail(QByteArray)), reciever, member);
break;
case ResultTimedOut:
connected = QObject::connect(this, SIGNAL(timedOut()), reciever, member);
break;
}
if (connected && !m_resultConnected.contains(code))
m_resultConnected << code;
return connected;
}
bool SleepCommand::executeCommand(QStringList * const arguments)
{
if (arguments->size() == 1)
{
const int periodInMs = arguments->first().toInt();
this->timer.setInterval(periodInMs);
this->timer.setSingleShot(true);
this->timer.start();
connect(&this->timer,
SIGNAL(timeout()),
SLOT(timedOut()));
// IMPORTANT: Return false and don't send any messages.
// This will silently fail and when the timer expires
// it will send the passed OK back to the client
//
// The client should be enforcing flow control and not
// execute anything until the OK message goes back.
//
// It also means that this thread of execution (event)
// can continue to process events without being held
// by the sleep
}
else
{
this->client->write("ERROR: Not enough arguments, sleep <timeInMs>\r\n");
}
return false;
}
NotificationTimeout::NotificationTimeout(NotificationModel *m, int id, int timeout)
:QTimer(m), m_id(id), m_model(m) {
setInterval(timeout);
setSingleShot(true);
connect(this, SIGNAL(timeout()),
this, SLOT(timedOut()));
start();
}
void KTimeout::timerEvent(QTimerEvent* ev) {
QHash<int, int>::const_iterator it = _timers.constBegin();
for ( ; it != _timers.constEnd(); ++it) {
if (it.value() == ev->timerId()) {
emit timedOut(it.key());
return;
}
}
}
/*!
Constructor
*/
NmApiEventNotifierPrivate::NmApiEventNotifierPrivate(QObject *parent) :
QObject(parent), mEmitSignals(NULL), mEngine(NULL), mIsRunning(false)
{
NM_FUNCTION;
mEmitSignals = new QTimer(this);
mEmitSignals->setInterval(IntervalEmitingSignals);
connect(mEmitSignals, SIGNAL(timeout()), this, SIGNAL(
timedOut()));
mEngine = NmApiEngine::instance();
}
void KTimeout::timeout() {
const QTimer *t = static_cast<const QTimer*>(sender());
if (t) {
QIntDictIterator<QTimer> it(_timers);
for (; it.current(); ++it) {
if (it.current() == t) {
emit timedOut(it.currentKey());
return;
}
}
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent), m_ApplicationOpenReminderEnabled(true),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
setWindowTitle(Version::getApplicationName().append(" (Version ").append(Version::getApplicationVersion().append(")")));
setWindowIcon(QIcon(":/icon.ico"));
createShortcuts();
m_GraphicsScene = new GraphicalGridScene(m_Crossword);
ui->graphicsView->setScene(m_GraphicsScene);
m_TableModel = new CrosswordEntryTableModel(m_Crossword, m_Crossword.getRefEntries());
m_ProxyModel = new QSortFilterProxyModel(this);
m_ProxyModel->setSourceModel(m_TableModel);
ui->wordTableView->setModel(m_ProxyModel);
m_IdleReminder = new IdleReminder(60000);
m_ClueReader = new ClueReader();
connect(this, SIGNAL(puzzleLoaded()), m_TableModel, SLOT(crosswordEntriesChanged()));
connect(this, SIGNAL(puzzleLoaded()), ui->wordTableView, SLOT(setFocus(Qt::OtherFocusReason)));
connect(this, SIGNAL(puzzleLoaded()), m_GraphicsScene, SLOT(buildPuzzleGrid()));
connect(m_TableModel, SIGNAL(conflictingWordError()), ui->wordTableView, SLOT(conflictingWordError()));
connect(ui->wordTableView, SIGNAL(modelIndexChanged(const QModelIndex&, const QModelIndex&)), m_TableModel, SLOT(tableViewSelectionChanged(const QModelIndex&, const QModelIndex&)));
connect(ui->wordTableView, SIGNAL(guessSubmitted(QString,QModelIndex)), this, SLOT(checkIfPuzzleWasCompleted()));
connect(ui->wordTableView, SIGNAL(guessSubmitted(QString, QModelIndex)), m_TableModel, SLOT(enterGuess(QString, QModelIndex)));
connect(ui->wordTableView, SIGNAL(guessAmendationRequested(QString, QModelIndex)), m_TableModel, SLOT(amendGuess(QString, QModelIndex)));
connect(ui->wordTableView, SIGNAL(guessErasureRequested(QModelIndex)), m_TableModel, SLOT(eraseGuess(QModelIndex)));
connect(m_TableModel, SIGNAL(guessValidated(QString)), ui->wordTableView, SLOT(reportGuessAccepted(QString)));
connect(m_TableModel, SIGNAL(guessAmended(QString)), ui->wordTableView, SLOT(reportGuessAmended(QString)));
connect(m_TableModel, SIGNAL(guessErased()), ui->wordTableView, SLOT(reportGuessErased()));
connect(m_TableModel, SIGNAL(guessAmendationRequestRejected()), ui->wordTableView, SLOT(reportGuessAmendationRejected()));
connect(m_TableModel, SIGNAL(guessValidated(QString)), m_GraphicsScene, SLOT(repaintPuzzleGrid()));
connect(m_TableModel, SIGNAL(guessAmended(QString)), m_GraphicsScene, SLOT(repaintPuzzleGrid()));
connect(m_TableModel, SIGNAL(guessErased()), m_GraphicsScene, SLOT(repaintPuzzleGrid()));
connect(m_TableModel, SIGNAL(crosswordEntrySelectionChanged(CrosswordEntry)), m_GraphicsScene, SLOT(highlightSelection(CrosswordEntry)));
connect(&m_CrosswordLoader, SIGNAL(loaderError(QString, QString)), this, SLOT(showError(QString, QString)));
connect(m_IdleReminder, SIGNAL(timedOut()), this, SLOT(onIdleReminderTimeout()));
qApp->installEventFilter(m_IdleReminder);
connect(m_TableModel, SIGNAL(crosswordEntrySelectionChanged(CrosswordEntry)), m_ClueReader, SLOT(setText(CrosswordEntry)));
ITextToSpeech::instance().speak(getIntroString());
}
MCpuMonitor::MCpuMonitor() : d_ptr(new MCpuMonitorPrivate)
{
Q_D(MCpuMonitor);
d->usable = false;
#ifdef __linux__
d->getCpuUsageInformation(d->jiffies_total, d->jiffies_idle);
#endif
connect(&d->timer, SIGNAL(timeout()), SLOT(timedOut()));
}
bool AMDetectorSet::addDetector(AMDetector *detector){
if(!detector)
return false;
if( append(detector, detector->name()) ){
connect(detector, SIGNAL(connected(bool)), this, SLOT(onConnectedChanged(bool)));
connect(detector, SIGNAL(timedOut()), this, SLOT(onTimedOut()));
onConnectedChanged(detector->isConnected());
emit detectorAdded(count() - 1);
return true;
}
SunscraperRPC::SunscraperRPC(QLocalSocket *socket) :
m_socket(socket), m_state(StateHeader), m_result(false)
{
m_nextQueryId += 1;
m_queryId = m_nextQueryId;
connect(m_socket, SIGNAL(readyRead()), this, SLOT(onInputReadable()));
connect(m_socket, SIGNAL(disconnected()), this, SLOT(onInputDisconnected()));
if(m_worker == NULL)
m_worker = new SunscraperWorker();
connect(m_worker, SIGNAL(finished(uint)), this, SLOT(onFinish(uint)));
connect(m_worker, SIGNAL(timedOut(uint)), this, SLOT(onTimeout(uint)));
connect(m_worker, SIGNAL(htmlFetched(uint,QString)), this, SLOT(onFetchDone(uint,QString)));
}
int64_t SSLSocket::readImpl(char *buffer, int64_t length) {
int64_t nr_bytes = 0;
if (m_data->m_ssl_active) {
bool retry = true;
do {
if (m_data->m_is_blocked) {
Socket::waitForData();
if (timedOut()) {
break;
}
// could get here and we only have parts of an SSL packet
}
nr_bytes = SSL_read(m_data->m_handle, buffer, length);
if (nr_bytes > 0) break; /* we got the data */
retry = handleError(nr_bytes, false);
setEof(!retry && errno != EAGAIN && !SSL_pending(m_data->m_handle));
} while (retry);
} else {
nr_bytes = Socket::readImpl(buffer, length);
}
return nr_bytes < 0 ? 0 : nr_bytes;
}
Foam::fileStat::fileStat(const fileName& fName, const unsigned int maxTime)
{
// Work on volatile
volatile bool locIsValid = false;
timer myTimer(maxTime);
if (!timedOut(myTimer))
{
if (::stat(fName.c_str(), &status_) != 0)
{
locIsValid = false;
}
else
{
locIsValid = true;
}
}
// Copy into (non-volatile, possible register based) member var
isValid_ = locIsValid;
}
bool KDLKinematicsPlugin::searchPositionIK(const geometry_msgs::Pose &ik_pose,
const std::vector<double> &ik_seed_state,
double timeout,
std::vector<double> &solution,
const IKCallbackFn &solution_callback,
moveit_msgs::MoveItErrorCodes &error_code,
const std::vector<double> &consistency_limits,
const kinematics::KinematicsQueryOptions &options) const
{
ros::WallTime n1 = ros::WallTime::now();
if(!active_)
{
ROS_ERROR_NAMED("kdl","kinematics not active");
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
if(ik_seed_state.size() != dimension_)
{
ROS_ERROR_STREAM_NAMED("kdl","Seed state must have size " << dimension_ << " instead of size " << ik_seed_state.size());
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
if(!consistency_limits.empty() && consistency_limits.size() != dimension_)
{
ROS_ERROR_STREAM_NAMED("kdl","Consistency limits be empty or must have size " << dimension_ << " instead of size " << consistency_limits.size());
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
KDL::JntArray jnt_seed_state(dimension_);
KDL::JntArray jnt_pos_in(dimension_);
KDL::JntArray jnt_pos_out(dimension_);
KDL::ChainFkSolverPos_recursive fk_solver(kdl_chain_);
KDL::ChainIkSolverVel_pinv_mimic ik_solver_vel(kdl_chain_, joint_model_group_->getMimicJointModels().size(), redundant_joint_indices_.size(), position_ik_);
KDL::ChainIkSolverPos_NR_JL_Mimic ik_solver_pos(kdl_chain_, joint_min_, joint_max_, fk_solver, ik_solver_vel, max_solver_iterations_, epsilon_, position_ik_);
ik_solver_vel.setMimicJoints(mimic_joints_);
ik_solver_pos.setMimicJoints(mimic_joints_);
if ((redundant_joint_indices_.size() > 0) && !ik_solver_vel.setRedundantJointsMapIndex(redundant_joints_map_index_))
{
ROS_ERROR_NAMED("kdl","Could not set redundant joints");
return false;
}
if(options.lock_redundant_joints)
{
ik_solver_vel.lockRedundantJoints();
}
solution.resize(dimension_);
KDL::Frame pose_desired;
tf::poseMsgToKDL(ik_pose, pose_desired);
ROS_DEBUG_STREAM_NAMED("kdl","searchPositionIK2: Position request pose is " <<
ik_pose.position.x << " " <<
ik_pose.position.y << " " <<
ik_pose.position.z << " " <<
ik_pose.orientation.x << " " <<
ik_pose.orientation.y << " " <<
ik_pose.orientation.z << " " <<
ik_pose.orientation.w);
//Do the IK
for(unsigned int i=0; i < dimension_; i++)
jnt_seed_state(i) = ik_seed_state[i];
jnt_pos_in = jnt_seed_state;
unsigned int counter(0);
while(1)
{
// ROS_DEBUG_NAMED("kdl","Iteration: %d, time: %f, Timeout: %f",counter,(ros::WallTime::now()-n1).toSec(),timeout);
counter++;
if(timedOut(n1,timeout))
{
ROS_DEBUG_NAMED("kdl","IK timed out");
error_code.val = error_code.TIMED_OUT;
ik_solver_vel.unlockRedundantJoints();
return false;
}
int ik_valid = ik_solver_pos.CartToJnt(jnt_pos_in, pose_desired, jnt_pos_out);
ROS_DEBUG_NAMED("kdl","IK valid: %d", ik_valid);
if(!consistency_limits.empty())
{
getRandomConfiguration(jnt_seed_state, consistency_limits, jnt_pos_in, options.lock_redundant_joints);
if( (ik_valid < 0 && !options.return_approximate_solution) || !checkConsistency(jnt_seed_state, consistency_limits, jnt_pos_out))
{
ROS_DEBUG_NAMED("kdl","Could not find IK solution: does not match consistency limits");
continue;
}
}
else
{
getRandomConfiguration(jnt_pos_in, options.lock_redundant_joints);
ROS_DEBUG_NAMED("kdl","New random configuration");
for(unsigned int j=0; j < dimension_; j++)
ROS_DEBUG_NAMED("kdl","%d %f", j, jnt_pos_in(j));
if(ik_valid < 0 && !options.return_approximate_solution)
{
ROS_DEBUG_NAMED("kdl","Could not find IK solution");
continue;
}
}
ROS_DEBUG_NAMED("kdl","Found IK solution");
for(unsigned int j=0; j < dimension_; j++)
solution[j] = jnt_pos_out(j);
if(!solution_callback.empty())
solution_callback(ik_pose,solution,error_code);
else
error_code.val = error_code.SUCCESS;
if(error_code.val == error_code.SUCCESS)
{
ROS_DEBUG_STREAM_NAMED("kdl","Solved after " << counter << " iterations");
ik_solver_vel.unlockRedundantJoints();
return true;
}
}
ROS_DEBUG_NAMED("kdl","An IK that satisifes the constraints and is collision free could not be found");
error_code.val = error_code.NO_IK_SOLUTION;
ik_solver_vel.unlockRedundantJoints();
return false;
}
void Ipc::timerEvent(QTimerEvent *event)
{
QByteArray data;
Message *msg;
enum Cmd cmd;
enum Result result;
(void) event;
if ((m_mode == ModeManager) && (m_cmdSent.msecsTo(QTime::currentTime()) > m_timeout)) // Проверка таймаута
{
stopTimer();
if (m_resultConnected.contains(ResultTimedOut))
emit timedOut(m_sentCmd);
else
{
std::cout << "Command execution timed out" << std::endl;
qApp->quit();
}
return;
}
if (m_shared.lock())
{
msg = (Message *)m_shared.constData();
if (msg->dataSize > 0)
data.append((const char *)(msg + 1), msg->dataSize);
}
else
return;
switch (m_mode)
{
case ModeApplication:
cmd = (enum Cmd)msg->code;
if (msg->sender == ModeManager)
{
#ifdef DEBUG
dbg << " i: IPC got command = " << cmd << " [" << data.toHex() << "]";
#endif
if (m_cmdConnected.contains(cmd))
{
stopTimer();
notify(cmd);
}
else
switch (cmd)
{
case CmdStatus:
if (m_state != StateNone)
send(ResultOk, QByteArray(1, m_state), true);
else
send(ResultNotImplemented, true);
break;
case CmdStop:
send(ResultOk, true);
qApp->quit();
break;
case CmdPid:
send(ResultOk, QByteArray::number(QApplication::applicationPid()), true);
break;
default:
send(ResultNotImplemented, true);
}
}
break;
case ModeManager:
result = (enum Result)msg->code;
if (msg->sender == ModeApplication)
{
#ifdef DEBUG
dbg << " i: IPC got response = " << result << " [" << data.toHex() << "]";
#endif
stopTimer();
if (m_resultConnected.contains(result))
notify(result, data);
else
{
switch (result)
{
case ResultOk:
switch (m_sentCmd)
{
case CmdPid:
std::cout << data.data() << std::endl;
break;
case CmdStop:
break;
default:
std::cout << "Command execution succeeded. Response dump: " << data.toHex().data() << std::endl;
break;
}
break;
case ResultNotImplemented:
std::cout << "Command not implemented" << std::endl;
break;
case ResultFail:
std::cout << "Error while executing command: " << data.data() << std::endl;
break;
default:;
}
qApp->quit();
}
}
break;
}
m_shared.unlock();
}
bool KDLKinematicsPlugin::searchPositionIK(const geometry_msgs::Pose &ik_pose,
const std::vector<double> &ik_seed_state,
double timeout,
std::vector<double> &solution,
const IKCallbackFn &solution_callback,
moveit_msgs::MoveItErrorCodes &error_code,
const std::vector<double> &consistency_limits) const
{
ros::WallTime n1 = ros::WallTime::now();
if(!active_)
{
ROS_ERROR("kinematics not active");
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
if(ik_seed_state.size() != dimension_)
{
ROS_ERROR_STREAM("Seed state must have size " << dimension_ << " instead of size " << ik_seed_state.size());
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
if(!consistency_limits.empty() && consistency_limits.size() != dimension_)
{
ROS_ERROR_STREAM("Consistency limits be empty or must have size " << dimension_ << " instead of size " << consistency_limits.size());
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
solution.resize(dimension_);
KDL::Frame pose_desired;
tf::poseMsgToKDL(ik_pose, pose_desired);
ROS_DEBUG_STREAM("searchPositionIK2: Position request pose is " <<
ik_pose.position.x << " " <<
ik_pose.position.y << " " <<
ik_pose.position.z << " " <<
ik_pose.orientation.x << " " <<
ik_pose.orientation.y << " " <<
ik_pose.orientation.z << " " <<
ik_pose.orientation.w);
//Do the IK
for(unsigned int i=0; i < dimension_; i++)
jnt_seed_state_(i) = ik_seed_state[i];
jnt_pos_in_ = jnt_seed_state_;
unsigned int counter(0);
while(1)
{
// ROS_DEBUG("Iteration: %d, time: %f, Timeout: %f",counter,(ros::WallTime::now()-n1).toSec(),timeout);
counter++;
if(timedOut(n1,timeout))
{
ROS_DEBUG("IK timed out");
error_code.val = error_code.TIMED_OUT;
return false;
}
int ik_valid = ik_solver_pos_->CartToJnt(jnt_pos_in_,pose_desired,jnt_pos_out_);
if(!consistency_limits.empty())
{
getRandomConfiguration(jnt_seed_state_, consistency_limits, jnt_pos_in_);
if(ik_valid < 0 || !checkConsistency(jnt_seed_state_, consistency_limits, jnt_pos_out_))
{
ROS_DEBUG("Could not find IK solution");
continue;
}
}
else
{
getRandomConfiguration(jnt_pos_in_);
if(ik_valid < 0)
{
ROS_DEBUG("Could not find IK solution");
continue;
}
}
ROS_DEBUG("Found IK solution");
for(unsigned int j=0; j < dimension_; j++)
solution[j] = jnt_pos_out_(j);
if(!solution_callback.empty())
solution_callback(ik_pose,solution,error_code);
else
error_code.val = error_code.SUCCESS;
if(error_code.val == error_code.SUCCESS)
{
ROS_DEBUG_STREAM("Solved after " << counter << " iterations");
return true;
}
}
ROS_DEBUG("An IK that satisifes the constraints and is collision free could not be found");
error_code.val = error_code.NO_IK_SOLUTION;
return false;
}
bool Foam::ping
(
const word& destName,
const label destPort,
const label timeOut
)
{
char *serverAddress;
struct in_addr *ptr;
struct hostent *hostPtr;
volatile int sockfd;
struct sockaddr_in destAddr; // will hold the destination addr
u_int addr;
if ((hostPtr = gethostbyname(destName.c_str())) == NULL)
{
FatalErrorIn
(
"Foam::ping(const word&, const label)"
) << "gethostbyname error " << h_errno << " for host " << destName
<< abort(FatalError);
}
// Get first of the SLL of addresses
serverAddress = *(hostPtr->h_addr_list);
ptr = reinterpret_cast<struct in_addr*>(serverAddress);
addr = ptr->s_addr;
// Allocate socket
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
FatalErrorIn
(
"Foam::ping(const word&, const label)"
) << "socket error"
<< abort(FatalError);
}
// Fill sockaddr_in structure with dest address and port
memset (reinterpret_cast<char *>(&destAddr), '\0', sizeof(destAddr));
destAddr.sin_family = AF_INET;
destAddr.sin_port = htons(ushort(destPort));
destAddr.sin_addr.s_addr = addr;
timer myTimer(timeOut);
if (timedOut(myTimer))
{
// Setjmp from timer jumps back to here
fdClose(sockfd);
return false;
}
if
(
connect
(
sockfd,
reinterpret_cast<struct sockaddr*>(&destAddr),
sizeof(struct sockaddr)
) != 0
)
{
// Connection refused. Check if network was actually used or not.
int connectErr = errno;
fdClose(sockfd);
if (connectErr == ECONNREFUSED)
{
return true;
}
//perror("connect");
return false;
}
fdClose(sockfd);
return true;
}
void ChooseGeneralBox::chooseGeneral(QStringList generals) {
//嶷仟紙崙嘘尚
if (generals.contains("anjiang(lord)")) generals.removeAll("anjiang(lord)");
general_number = generals.length();
update();
items.clear();
selected.clear();
foreach(QString general, generals) {
if (general.endsWith("(lord)")) continue;
GeneralCardItem *general_item = new GeneralCardItem(general);
general_item->setFlag(QGraphicsItem::ItemIsFocusable);
if (single_result)
general_item->setFlag(QGraphicsItem::ItemIsMovable, false);
else {
general_item->setAutoBack(true);
connect(general_item, SIGNAL(released()), this, SLOT(_adjust()));
}
connect(general_item, SIGNAL(clicked()), this, SLOT(_onItemClicked()));
connect(general_item, SIGNAL(enter_hover()), this, SLOT(_onCardItemHover()));
connect(general_item, SIGNAL(leave_hover()), this, SLOT(_onCardItemLeaveHover()));
connect(general_item, SIGNAL(general_changed()), this, SLOT(adjustItems()));
if (!single_result) {
const General *hero = Sanguosha->getGeneral(general);
foreach (QString other, generals) {
if (other.endsWith("(lord)")) continue;
if (general != other && hero->isCompanionWith(other)) {
general_item->showCompanion();
break;
}
}
}
items << general_item;
general_item->setParentItem(this);
}
setPos(RoomSceneInstance->tableCenterPos() - QPointF(boundingRect().width() / 2, boundingRect().height() / 2));
show();
int card_width = G_COMMON_LAYOUT.m_cardNormalWidth;
int card_height = G_COMMON_LAYOUT.m_cardNormalHeight;
int first_row = (general_number < 6) ? general_number : ((general_number + 1) / 2);
for (int i = 0; i < items.length(); ++ i) {
GeneralCardItem *card_item = items.at(i);
QPointF pos;
if (i < first_row) {
pos.setX(left_blank_width + (card_width + card_to_center_line) * i + card_width / 2);
pos.setY(top_blank_width + card_height / 2);
} else {
if (items.length() % 2 == 1)
pos.setX(left_blank_width + card_width / 2 + card_to_center_line / 2
+ (card_width + card_to_center_line) * (i - first_row) + card_width / 2);
else
pos.setX(left_blank_width + (card_width + card_to_center_line) * (i - first_row) + card_width / 2);
pos.setY(top_blank_width + card_height + card_to_center_line + card_height / 2);
}
card_item->setPos(25, 45);
if (!single_result)
//委厘社優廖峽贋和栖�契峭指音栖
card_item->setData(S_DATA_INITIAL_HOME_POS, pos);
card_item->setHomePos(pos);
card_item->goBack(true);
}
if (single_result)
confirm->hide();
else {
confirm->setPos(boundingRect().center().x() - confirm->boundingRect().width() / 2, boundingRect().height() - 60);
confirm->show();
}
_initializeItems();
if (ServerInfo.OperationTimeout != 0) {
if (!progress_bar) {
progress_bar = new QSanCommandProgressBar();
progress_bar->setMinimumWidth(200);
progress_bar->setMaximumHeight(12);
progress_bar->setTimerEnabled(true);
progress_bar_item = new QGraphicsProxyWidget(this);
progress_bar_item->setWidget(progress_bar);
progress_bar_item->setPos(boundingRect().center().x() - progress_bar_item->boundingRect().width() / 2, boundingRect().height() - 30);
connect(progress_bar, SIGNAL(timedOut()), this, SLOT(reply()));
}
progress_bar->setCountdown(QSanProtocol::S_COMMAND_CHOOSE_GENERAL);
progress_bar->show();
}
}
void PlayerCardBox::chooseCard(const QString &reason, const ClientPlayer *player,
const QString &flags, bool handcardVisible,
Card::HandlingMethod method, const QList<int> &disabledIds)
{
nameRects.clear();
rowCount = 0;
intervalsBetweenAreas = -1;
intervalsBetweenRows = 0;
maxCardsInOneRow = 0;
this->player = player;
this->title = tr("%1: please choose %2's card").arg(reason).arg(ClientInstance->getPlayerName(player->objectName()));
this->flags = flags;
bool handcard = false;
bool equip = false;
bool judging = false;
if (flags.contains(handcardFlag) && !player->isKongcheng()) {
updateNumbers(player->getHandcardNum());
handcard = true;
}
if (flags.contains(equipmentFlag) && player->hasEquip()) {
updateNumbers(player->getEquips().length());
equip = true;
}
if (flags.contains(judgingFlag) && !player->getJudgingArea().isEmpty()) {
updateNumbers(player->getJudgingArea().length());
judging = true;
}
int max = maxCardsInOneRow;
int maxNumber = maxCardNumberInOneRow;
maxCardsInOneRow = qMin(max, maxNumber);
prepareGeometryChange();
moveToCenter();
show();
this->handcardVisible = handcardVisible;
this->method = method;
this->disabledIds = disabledIds;
const int startX = verticalBlankWidth + placeNameAreaWidth + intervalBetweenNameAndCard;
int index = 0;
if (handcard) {
if (Self == player || handcardVisible) {
arrangeCards(player->getHandcards(), QPoint(startX, nameRects.at(index).y()));
} else {
const int handcardNumber = player->getHandcardNum();
CardList cards;
for(int i = 0; i < handcardNumber; ++ i)
cards << NULL;
arrangeCards(cards, QPoint(startX, nameRects.at(index).y()));
}
++ index;
}
if (equip) {
arrangeCards(player->getEquips(), QPoint(startX, nameRects.at(index).y()));
++ index;
}
if (judging)
arrangeCards(player->getJudgingArea(), QPoint(startX, nameRects.at(index).y()));
if (ServerInfo.OperationTimeout != 0) {
if (!progressBar) {
progressBar = new QSanCommandProgressBar();
progressBar->setMaximumWidth(qMin(boundingRect().width() - 16, (qreal) 150));
progressBar->setMaximumHeight(12);
progressBar->setTimerEnabled(true);
progressBarItem = new QGraphicsProxyWidget(this);
progressBarItem->setWidget(progressBar);
progressBarItem->setPos(boundingRect().center().x() - progressBarItem->boundingRect().width() / 2, boundingRect().height() - 20);
connect(progressBar, SIGNAL(timedOut()), this, SLOT(reply()));
}
progressBar->setCountdown(QSanProtocol::S_COMMAND_CHOOSE_CARD);
progressBar->show();
}
}
