ClientTransportAutoPtr Win32NamedPipeSessionState::implCreateClientTransport()
{
HANDLE hPipe = INVALID_HANDLE_VALUE;
{
Lock lock(mMutex);
if (mOwnFd && !mHasBeenClosed)
{
mOwnFd = false;
mEnableReconnect = false;
hPipe = mhPipe;
}
}
std::auto_ptr<Win32NamedPipeClientTransport> w32PipeClientTransport(
new Win32NamedPipeClientTransport(hPipe));
w32PipeClientTransport->setNotifyCloseFunctor( boost::bind(
&IocpSessionState::notifyClose,
IocpSessionStateWeakPtr(sharedFromThis())));
w32PipeClientTransport->setPipeName(mRemotePipeName);
return ClientTransportAutoPtr(w32PipeClientTransport.release());
}
void GobanIA::ajouterGroupe(boost::shared_ptr<Groupe> groupePtr)
{
m_groupes.insert(groupePtr);
groupePtr->setGoban(sharedFromThis());
}
DeviceProcess *DesktopDevice::createProcess(QObject *parent) const
{
return new Internal::DesktopDeviceProcess(sharedFromThis(), parent);
}
DeviceProcessList *DesktopDevice::createProcessListModel(QObject *parent) const
{
return new Internal::LocalProcessList(sharedFromThis(), parent);
}
SAWYER_EXPORT Function::Ptr
Function::arg(const std::string &name, const std::string &dflt) {
formals_.push_back(FormalArg(name, dflt));
return sharedFromThis();
}
QWidget *VigaSimplementeApoyada::getEditWidget()
{
WidgetVigaSimplementeApoyada *widget = new WidgetVigaSimplementeApoyada();
widget->setViga(sharedFromThis());
return widget;
}
bool appl::TextViewer::isSelectedLast() {
if (m_viewerManager != nullptr) {
return m_viewerManager->isLastSelected(ememory::dynamicPointerCast<appl::TextViewer>(sharedFromThis()));
}
return false;
}
void MenuBar::addItem(const MenuItemPtr &item)
{
items.push_back(item);
item->addedToMenuBar(sharedFromThis());
}
void Entry::init(const QJsonObject& data)
{
_initBase(data);
_createdAt = Tasty::parseDate(data.value("created_at").toString());
_url = data.value("entry_url").toString();
_isVotable = data.value("is_voteable").toBool();
_isFavoritable = data.value("can_favorite").toBool(Tasty::instance()->isAuthorized());
_isFavorited = data.value("is_favorited").toBool();
_isWatchable = data.value("can_watch").toBool();
_isWatched = data.value("is_watching").toBool();
_isPrivate = data.value("is_private").toBool();
_isFixed = data.value("fixed_state").toString() == "fixed";
auto fixDate = data.value("fixed_up_at").toString();
_fixedAt = QDateTime::fromString(fixDate.left(19), "yyyy-MM-ddTHH:mm:ss");
auto me = Tasty::instance()->me();
auto isMy = me && _author->id() == me->id();
_isDeletable = data.value("can_delete").toBool(isMy);
_isEditable = data.value("can_edit").toBool(isMy);
auto tlogData = data.value("tlog").toObject();
if (_tlog && tlogData.contains("slug"))
_tlog->init(tlogData);
else
_tlog = new Tlog(tlogData, this);
// if (data.contains("rating"))
// {
// if (_rating)
//
// else
// _rating = new Rating(data.value("rating").toObject(), this);
// }
if (!_rating)
_rating = new Rating(this);
if (isLoading())
_rating->init(data.value("rating").toObject());
else
_rating->setId(_id);
_commentsCount = data.value("comments_count").toInt();
if (data.contains("title_truncated"))
_truncatedTitle = data.value("title_truncated").toString();
else if (_truncatedTitle.isEmpty())
_truncatedTitle = Tasty::truncateHtml(_title, 100);
if (data.contains("text_truncated"))
_truncatedText = data.value("text_truncated").toString();
else if (_truncatedText.isEmpty())
_truncatedText = Tasty::truncateHtml(_text, 300);
_source = data.value("source").toString(); // quote author
delete _media;
_media = _type == "video" ? new Media(data.value("iframely").toObject(), this)
: nullptr; // music?
// _imagePreview = data.value("preview_image").toObject();
QRegularExpression wordRe("\\s[^\\s]+\\s");
QRegularExpression tagRe("<[^>]*>");
// QRegularExpression wordRe("\\b\\w+\\b");
auto content = _title + _text;
_wordCount = content.remove(tagRe).count(wordRe);
_correctHtml();
pTasty->dataCache()->addEntry(sharedFromThis());
_commentsData = data.value("comments").toArray();
if (_commentsModel && _commentsModel->entryId() == _id)
{
_commentsModel->init(_commentsData, _commentsCount);
_commentsData = QJsonArray();
}
auto imageAttach = data.value("image_attachments").toArray();
delete _attachedImagesModel;
_attachedImagesModel = new AttachedImagesModel(&imageAttach, this);
_rating->reCalcBayes();
emit updated();
emit commentsCountChanged();
}
void Widget::setMouseOverHere()
{
getSystemWindow()->setMouseFocusWidget(sharedFromThis());
}
void Widget::setFocusHere()
{
getSystemWindow()->setKeyboardFocusWidget(sharedFromThis());
}
void Widget::captureMouse()
{
getSystemWindow()->setMouseCaptureWidget(sharedFromThis());
}
void Widget::popKill(const WidgetPtr &popupGroup)
{
getSystemWindow()->killPopUp(sharedFromThis(), popupGroup);
}
void Widget::popUp(const WidgetPtr &popupGroup)
{
getSystemWindow()->activatePopUp(sharedFromThis(), popupGroup);
}
SAWYER_EXPORT Function::Ptr
Function::ellipsis(size_t n) {
ellipsis_ = n;
return sharedFromThis();
}
bool GobanIA::coupPossible(int abs, int ord)
{
try
{
std::pair<int,int> coord (abs,ord);
std::map<std::pair<int,int>,boost::shared_ptr<Pierre> > plateau = getPlateau();
if ((plateau.find(coord)!=plateau.end()) || (abs < 0) || (abs > 9) || (ord < 0) || (ord > 9))
{
return false;
}
else
{
boost::shared_ptr<Pierre> p;
if ("noir"==getPartieIA()->couleurAJouer())
{
Coup c(abs,ord, m_partie->getNoir());
c.setNum(getPartieIA()->getListeCoups().size());
p.reset(new Pierre(c,ECART()));
}
else
{
Coup c(abs,ord, m_partie->getBlanc());
c.setNum(getPartieIA()->getListeCoups().size());
p.reset(new Pierre(c,ECART()));
}
m_copie.reset(new GobanIA(5,9));
m_copie->m_partie=m_partie;
m_copie->copieGroupes(sharedFromThis());
try
{
m_copie->ajouterPierre(p,false);
}
catch(coupImpossible& e)
{
std::cout << "Coup impossible\n";
return false;
}
return true;
// if (p->getGroupe().get()!=0)
// {
//// if (p->getGroupe()->nbLibertes()==0)
//// {
//// std::cout << "Groupe auquel la pierre ajoutée appartient n'a pas de libertés\n";
//// return false;
//// }
// std::cout << "coup possible !\n";
// return true;
// }
// else throw coup_exception("Erreur pierre mal ajoutée au goban copie");
// m_copie.reset();
}
// return true;
///TODO à terminer
}
catch(std::exception const& e)
{
std::ostringstream errorMsg;
errorMsg << "Impossible de déterminer si le coup " << abs << " - " << ord << " est possible : \n " << e.what();
throw coup_exception(errorMsg.str());
}
}
ModelCommons::ReadyFlags TrackerContentModule::refreshModel_chain
(LiveNodeModel::RefreshMode mode, InterfaceChain<ModelCommons> chain)
{
// << "TrackerContentModule(" << this << ")::" << __func__
// << "mode(" << mode << "), running(" << running() << ")"
// << "completion_watcher(" << completion_watcher_ << ")";
if(!service_->resources.isValid()) {
warning(service_.data()) << service_->resources.lastError();
return ReadyFlags();
}
ReadyFlags ret = ContentModule_Simple::refreshModel_chain(mode, chain);
// First step of refresh: flush the query if requested.
// This is also how a new query is started, the entity creating the
// TrackerContentModule passes the query in the constructor, and when the
// module is attached(), a flushing refresh is initiated.
if(mode & LiveNodeModel::Flush)
{
abort();
setRunning(true);
PERF_EVENT("sequencing %d", query_id_);
// will sequence the call to "sequencedStart"
// should add sequencing by query_id as a quality, and possibly depend on a pending
// query, if one cant be aborted for some reason
QSharedPointer<TrackerContentModule> self
= sharedFromThis<TrackerContentModule>();
sequenced_ = service_->query_sequencer_.addOperation
( tracker_access_->sequencingQualities()
, tracker_access_->sequencingDependencies()
, SequencerSlotCall::shared(self, "sequencedStart")
, SequencerSignal::shared(self, SIGNAL(sequencedSuccess()))
, SequencerSignal::shared(self, SIGNAL(sequencedFailure())));
ret = NothingReady;
}
// second step of refresh: if blocking, wait for all necessary steps for
// query to complete
if((mode & LiveNodeModel::Block) && running())
{
if(sequenced_ && !pending_sequenced_)
{
pending_sequenced_ = true;
QSharedPointer<SequencedOperation> seq = sequenced_;
PERF_EVENT("before_sequence_wait %d", query_id_);
// wait for sequencedStart to be called if not already so.
// During the wait we might get aborted. Make as little assumptions
// as possible
seq->waitForStarted();
PERF_EVENT("after_sequence_wait %d", query_id_);
if(seq->state() > SequencedOperation::Succeeded)
// failed (typically aborted)
model()->emitErrorImpl(seq->stateString(), 0, QModelIndex(), false);
pending_sequenced_ = false;
}
// The wait is here because TrackerUpdateModule might have multi-step
// completion cycle.
tracker_access_->waitForQueryComplete();
}
// third step of refresh: if a query has completed, process the results
TrackerQueryResult queryResult(tracker_access_->takeQueryResult());
if(queryResult.isFinished())
{
setRunning(false);
sequenced_.clear();
if(queryResult.isError())
{
QString error_message = queryResult.errorMessage();
if(RowStoreModel *m = model())
m->emitErrorImpl(error_message, 0, QModelIndex(), !(mode & LiveNodeModel::Block));
warning(service_.data()) << "error while modeling query (id =" << query_id_
<< "):\n" << error_message;
debug(4, service_.data()) << " query was:\n" << getQueryText() << "\n";
sharedFromThis(), Q_EMIT sequencedFailure();
ret = NothingReady;
} else
{
ret = processResults(queryResult);
}
}
return ret;
}
void Win32NamedPipeNetworkSession::implRead(char * buffer, std::size_t bufferLen)
{
if ( !mSocketPtr )
{
RCF_LOG_4() << "Win32NamedPipeNetworkSession - connection has been closed.";
return;
}
RCF_LOG_4()(bufferLen)
<< "Win32NamedPipeNetworkSession - calling ReadFile().";
ASIO_NS::windows::overlapped_ptr overlapped(
mSocketPtr->get_io_service(),
ReadHandler(sharedFromThis()));
DWORD dwBytesRead = 0;
bool readOk = false;
HANDLE hPipe = mSocketPtr->native();
BOOL ok = ReadFile(
hPipe,
buffer,
static_cast<DWORD>(bufferLen),
&dwBytesRead,
overlapped.get());
DWORD realError = 0;
DWORD dwErr = 0;
if (!ok)
{
dwErr = GetLastError();
if ( dwErr != ERROR_IO_PENDING
&& dwErr != ERROR_MORE_DATA)
{
realError = dwErr;
}
}
if ( dwBytesRead
|| (ok && dwBytesRead == 0 && bufferLen == 0)
|| (!ok && realError == 0))
{
readOk = true;
}
if (readOk)
{
overlapped.release();
}
else
{
AsioErrorCode ec(
dwErr,
ASIO_NS::error::get_system_category());
overlapped.complete(ec, 0);
}
}
void appl::TextViewer::setCurrentSelect() {
if (m_viewerManager != nullptr) {
m_viewerManager->setViewerSelected(ememory::dynamicPointerCast<appl::TextViewer>(sharedFromThis()), m_buffer);
}
}
bool ewol::widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
bool previousHoverState = m_mouseHover;
if(gale::key::status::leave == _event.getStatus()) {
m_mouseHover = false;
m_buttonPressed = false;
} else {
vec2 relativePos = relativePosition(_event.getPos());
// prevent error from ouside the button
if( relativePos.x() < m_selectableAreaPos.x()
|| relativePos.y() < m_selectableAreaPos.y()
|| relativePos.x() > m_selectableAreaPos.x() + m_selectableAreaSize.x()
|| relativePos.y() > m_selectableAreaPos.y() + m_selectableAreaSize.y() ) {
m_mouseHover = false;
m_buttonPressed = false;
} else {
m_mouseHover = true;
}
}
bool previousPressed = m_buttonPressed;
//EWOL_DEBUG("Event on BT ... mouse position : " << m_mouseHover);
if (true == m_mouseHover) {
if (1 == _event.getId()) {
if(gale::key::status::down == _event.getStatus()) {
m_buttonPressed = true;
markToRedraw();
}
if(gale::key::status::up == _event.getStatus()) {
m_buttonPressed = false;
markToRedraw();
}
if(gale::key::status::pressSingle == _event.getStatus()) {
m_buttonPressed = false;
m_mouseHover = false;
// create a context menu :
m_widgetContextMenu = ewol::widget::ContextMenu::create();
if (m_widgetContextMenu == nullptr) {
EWOL_ERROR("Allocation Error");
return true;
}
vec2 tmpPos = m_origin + m_selectableAreaPos + m_selectableAreaSize;
tmpPos.setX( tmpPos.x() - m_minSize.x()/2.0);
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markButtom, tmpPos );
ewol::widget::ColorChooserShared myColorChooser = widget::ColorChooser::create();
myColorChooser->propertyValue.set(propertyValue.get());
// set it in the pop-up-system :
m_widgetContextMenu->setSubWidget(myColorChooser);
myColorChooser->signalChange.connect(sharedFromThis(), &ewol::widget::ButtonColor::onCallbackColorChange);
ewol::widget::WindowsShared currentWindows = getWindows();
if (currentWindows == nullptr) {
EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu.reset();
} else {
currentWindows->popUpWidgetPush(m_widgetContextMenu);
}
markToRedraw();
}
}
}
if( m_mouseHover != previousHoverState
|| m_buttonPressed != previousPressed) {
if (m_buttonPressed == true) {
changeStatusIn(STATUS_PRESSED);
} else {
if (m_mouseHover == true) {
changeStatusIn(STATUS_HOVER);
} else {
changeStatusIn(STATUS_UP);
}
}
}
return m_mouseHover;
}
void globals::ParameterGlobalsGui::init() {
ewol::widget::Sizer::init();
propertyMode.set(ewol::widget::Sizer::modeVert);
ememory::SharedPtr<ewol::widget::CheckBox> myCheckbox;
ememory::SharedPtr<ewol::widget::Spacer> mySpacer;
mySpacer = ewol::widget::Spacer::create();
if (mySpacer == nullptr) {
APPL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySpacer->propertyExpand.set(bvec2(true,true));
subWidgetAdd(mySpacer);
}
myCheckbox = ewol::widget::CheckBox::create();
if (myCheckbox == nullptr) {
APPL_ERROR("Can not allocate widget == > display might be in error");
} else {
//TODO : myCheckbox->propertyLabel.set("Automatic Indentation");
myCheckbox->propertyExpand.set(bvec2(true,false));
myCheckbox->propertyValue.set(isSetAutoIndent());
myCheckbox->signalValue.connect(sharedFromThis(), &globals::ParameterGlobalsGui::onCallbackIndentation);
subWidgetAdd(myCheckbox);
}
myCheckbox = ewol::widget::CheckBox::create();
if (myCheckbox == nullptr) {
APPL_ERROR("Can not allocate widget == > display might be in error");
} else {
//TODO : myCheckbox->propertyLabel.set("Display space char (' ')");
myCheckbox->propertyExpand.set(bvec2(true,false));
myCheckbox->propertyValue.set(isSetDisplaySpaceChar());
myCheckbox->signalValue.connect(sharedFromThis(), &globals::ParameterGlobalsGui::onCallbackSpace);
subWidgetAdd(myCheckbox);
}
myCheckbox = ewol::widget::CheckBox::create();
if (myCheckbox == nullptr) {
APPL_ERROR("Can not allocate widget == > display might be in error");
} else {
//TODO : myCheckbox->propertyLabel.set("Display tabulation char ('\\t')");
myCheckbox->propertyExpand.set(bvec2(true,false));
myCheckbox->propertyValue.set(isSetDisplayTabChar());
myCheckbox->signalValue.connect(sharedFromThis(), &globals::ParameterGlobalsGui::onCallbackTabulation);
subWidgetAdd(myCheckbox);
}
myCheckbox = ewol::widget::CheckBox::create();
if (myCheckbox == nullptr) {
APPL_ERROR("Can not allocate widget == > display might be in error");
} else {
//TODO : myCheckbox->propertyLabel.set("Display end of line ('\\n')");
myCheckbox->propertyExpand.set(bvec2(true,false));
myCheckbox->propertyValue.set(isSetDisplayEndOfLine());
myCheckbox->signalValue.connect(sharedFromThis(), &globals::ParameterGlobalsGui::onCallbackEndOfLine);
subWidgetAdd(myCheckbox);
}
myCheckbox = ewol::widget::CheckBox::create();
if (myCheckbox == nullptr) {
APPL_ERROR("Can not allocate widget == > display might be in error");
} else {
//TODO : myCheckbox->propertyLabel.set("switch Rounded/default");
myCheckbox->propertyExpand.set(bvec2(true,false));
myCheckbox->propertyValue.set(isSetDisplayEndOfLine());
myCheckbox->signalValue.connect(sharedFromThis(), &globals::ParameterGlobalsGui::onCallbackRounded);
subWidgetAdd(myCheckbox);
}
}
ProjectExplorer::IDeviceWidget *MerHardwareDevice::createWidget()
{
return new MerHardwareDeviceWidget(sharedFromThis());
}
QWidget *Viga::getEditWidget()
{
WidgetTipologia *widget = new WidgetTipologia();
widget->setTipologia(sharedFromThis());
return widget;
}
SAWYER_EXPORT Function::Ptr
Function::arg(const std::string &name) {
ASSERT_require(nOptionalArgs() == 0);
formals_.push_back(FormalArg(name));
return sharedFromThis();
}
