CWizFolderSelector::CWizFolderSelector(const QString& strTitle, CWizExplorerApp& app,
unsigned int nPermission, QWidget *parent)
: QDialog(parent)
, m_app(app)
, m_nMinPermission(nPermission)
, m_bAcceptRoot(true)
, m_bKeepTime(true)
, m_bKeepTags(true)
{
setWindowTitle(strTitle);
setFixedSize(400, 420);
QVBoxLayout* layout = new QVBoxLayout(this);
setLayout(layout);
m_folderView = new CWizFolderView(app, this);
layout->addWidget(m_folderView);
QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
buttonBox->button(QDialogButtonBox::Ok)->setText(tr("OK"));
buttonBox->button(QDialogButtonBox::Cancel)->setText(tr("Cancel"));
connect(buttonBox, SIGNAL(accepted()), SLOT(on_accept()));
connect(buttonBox, SIGNAL(rejected()), SLOT(reject()));
layout->addWidget(buttonBox);
}
xui_method_explain(onity_recent, on_buttonclick, void )( xui_component* sender, xui_method_args& args )
{
if (sender == m_browse)
{
std::wstring path = xui_global::get_openpath();
if (path.length() > 0)
{
xui_treenode* curr = NULL;
for (u32 i = 0; i < m_recent->get_upmostnodecount(); ++i)
{
xui_treenode* node = m_recent->get_upmostnode(i);
xui_treedata* data = node->get_linkdata();
if (data->get_text(0) == path)
{
curr = node;
break;
}
}
if (curr == NULL)
curr = m_recent->add_upmostnode(0, new xui_treedata(path));
m_recent->set_selectednode(curr, true);
}
}
if (m_recent->get_selectednode().empty())
return;
xui_method_args other_args;
on_accept(this, other_args);
}
xui_method_explain(onity_selector, on_fileviewdoubleclk, void )( xui_component* sender, xui_method_mouse& args )
{
if (args.mouse == MB_L)
{
std::vector<xui_treenode*> vec = m_fileview->get_lineview()->get_selectednode();
if (vec.size() > 0)
{
xui_treenode* node = vec.front();
onity_treedata* data = (onity_treedata*)node->get_linkdata();
onity_propfile* prop = dynamic_cast<onity_propfile*>(data->get_prop());
if (prop && prop->get_dragtype().length() == 0)
{
onity_tileview* tileview = m_fileview->get_tileview();
tileview->set_viewfile(node, xui_global::get_upper(m_search->get_text()));
refresh_backpath();
m_slider->set_data((void*)m_slider->get_value());
if (m_slider->get_value() == 0)
m_slider->set_value(10);
}
else
{
xui_method_args other_args;
on_accept(this, other_args);
}
}
}
}
void start_services ()
{
init_services ();
bzero (&user_list_head, sizeof (struct socket_list));
bzero (rooms, sizeof (rooms));
int i;
for (i = 0; i < MAXROOM; i++)
rooms[i].index = i;
printf ("running services...\n");
struct epoll_event events[MAXEVENTS];
int nfds;
while (1)
{
nfds = epoll_wait (epoll_fd, events, MAXEVENTS, -1);
if (nfds == -1)
{
perror ("epoll_wait");
continue;
}
for (i = 0; i < nfds; ++i)
{
if (events[i].data.fd == listen_socket)
on_accept ();
else
on_receive (events[i].data.fd);
}
}
}
int main(int argc, char** argv){
constexpr uint16_t port = 3000;
//////////
//epoll
int epoll_fd = epoll_create(10);
///////////////
//listen
{
int r_val;
struct sockaddr_in sockadd;
bzero(&sockadd, sizeof sockadd);
sockadd.sin_family = AF_INET;
sockadd.sin_addr.s_addr = INADDR_ANY;
sockadd.sin_port = hton16(port);
int fd = socket(AF_INET, SOCK_STREAM, 0);
int val = 1;
r_val = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof val);
r_val = bind(fd, (struct sockaddr*)&sockadd, sizeof sockadd);
r_val = listen(fd, 0);
Epoll_event_handle *ev_h = new Epoll_event_handle;
ev_h->on_event = [epoll_fd, fd](
struct epoll_event* ev){
on_accept(fd, epoll_fd);
};
struct epoll_event ev;
ev.events = EPOLLIN|EPOLLPRI|EPOLLRDHUP|EPOLLERR|EPOLLHUP;
ev.data.ptr = (void*)ev_h;
r_val = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
}
//////////////
// main event loop
constexpr int max_event_count = 16;
struct epoll_event events[max_event_count];
while (1){
int r_val = epoll_wait(epoll_fd, events, max_event_count, -1);
if (r_val == -1){
if (errno == EINTR){
continue;
}
else{
return 0;
}
}
for (int i = 0; i<r_val; i++){
Epoll_event_handle* ev_h =
(Epoll_event_handle*) events[i].data.ptr;
ev_h->on_event(events+i);
}
}
}
/*
//event
*/
xui_method_explain(onity_recent, on_recentdoubleclick, void )( xui_component* sender, xui_method_mouse& args )
{
if (m_recent->get_selectednode().empty())
return;
xui_method_args other_args;
on_accept(this, other_args);
}
int app::run(){
while(m_brun){
void* data = NULL;
if(m_ring_buf.pop(data) == -1){
continue;
}
app_hd * msg = (app_hd*)data;
if(msg->type == tcp_type){
switch(msg->event){
case ev_sys_recv:
on_recv(msg->u.tcp.n, msg->content, msg->length);
break;
case ev_sys_close:
on_close(msg->u.tcp.n, *((int*)msg->content));
delete msg->u.tcp.n;
break;
case ev_sys_accept:
on_accept(msg->u.tcp.n);
break;
case ev_sys_connect_ok:
on_connect(msg->u.tcp.n);
break;
case ev_sys_connect_fail:
on_connect(msg->u.tcp.n);
delete msg->u.tcp.n;
break;
}
}
else if(msg->type == timer_type){
on_timer(msg->event, msg->u.timer.interval, msg->u.timer.ptr);
}
else if(msg->type == app_type){
on_app(msg->event, msg->content, msg->length);
}
else{
error_log("msg from unknown app_name(%s)\n", m_name);
}
free(msg);
}
return 0;
}
/** Create a pop-up widget used to configure the transformation of the selected sensor. The contstrutor
* create a new instance of all available transformations. At the end unused transformation are distroyed
* @brief SensorTransformationConfig::SensorTransformationConfig
* @param sensor The sensor that handle the transformation
* @param parent The parent window
*/
SensorTransformationConfig::SensorTransformationConfig(RegisteredSensorItem *sensor, QWidget *parent) :
QWidget(parent),
ui(new Ui::SensorTransformationConfig)
{
ui->setupUi(this);
setWindowFlags(Qt::Tool);
setAttribute(Qt::WA_DeleteOnClose);
setWindowTitle(QString("Sensor [%1] : Transformation configuration").arg(sensor->name()));
m_linkedSensor = sensor;
QList<TransformationBaseClass *> transformationList = TransformationManager::instance()->getTransformations();
QStandardItemModel *model = new QStandardItemModel();
//QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel();
//proxyModel->setSourceModel(model);
model->setItem(0,new QStandardItem("None"));
m_transformationList.append(NULL);
TransformationBaseClass *sensorTransformation = sensor->transformation();
m_currentIndex = 0;
for(int i=0;i<transformationList.count();++i){
TransformationBaseClass *tr = transformationList[i]->newInstance();
m_transformationList.append(tr);
QString name = tr->getTransformationDefinition().name;
if(sensorTransformation && name == sensorTransformation->getTransformationDefinition().name){
tr->setParameters(sensorTransformation->getParameters());
m_currentIndex = i+1;
}
model->setItem(i+1,new QStandardItem(name));
}
//proxyModel->sort(0);
ui->comboBox->setModel(model);
ui->transformationDescription->setText("");
ui->comboBox->setCurrentIndex(m_currentIndex);
connect(ui->comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(on_transformationSelection(int)));
//ui->comboBox->view()->
connect(ui->comboBox->view(), SIGNAL(entered(QModelIndex)), this, SLOT(on_comboxItemEnter(QModelIndex)));
on_transformationSelection(m_currentIndex);
connect(ui->acceptButtonBox, SIGNAL(accepted()), this, SLOT(on_accept()));
connect(ui->acceptButtonBox, SIGNAL(rejected()), this, SLOT(close()));
}
int app::dispatch(const app_hd * msg){
if(msg->type == tcp_type){
switch(msg->event){
case ev_sys_recv:
on_recv(msg->u.tcp.n, msg->content, msg->length);
break;
case ev_sys_close:
on_close(msg->u.tcp.n, *((int*)msg->content));
delete msg->u.tcp.n;
break;
case ev_sys_accept:
on_accept(msg->u.tcp.n);
break;
case ev_sys_connect_ok:
on_connect(msg->u.tcp.n);
break;
case ev_sys_connect_fail:
on_connect(msg->u.tcp.n);
delete msg->u.tcp.n;
break;
case ev_sys_write:
handle_write(msg->u.tcp.n);
break;
}
}
else if(msg->type == timer_type){
on_timer(msg->event, msg->u.timer.interval, msg->u.timer.ptr);
}
else if(msg->type == app_type){
on_app(msg->event, msg->content, msg->length);
}
else{
error_log("msg from unknown app_name(%s)\n", m_name);
}
return 0;
}
int master_epoll_start(int epoll_fd, unsigned int max_events, int listen_sock)
{
int nfds;
struct epoll_event events[max_events];
nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, EPOLL_DELAY);
if(nfds == -1) {
perror("epoll_wait");
return L_HTTP_FAIL;
}
for(int n = 0; n < nfds; ++n) {
if (events[n].data.fd == listen_sock) {
if(on_accept(epoll_fd, listen_sock) == L_HTTP_FAIL)
continue;
}
}
return L_HTTP_SUCCESS;
}
/* Event manager callback when reads are ready. */
static void on_accept(void *arg, int from_iocp) {
server_port *sp = arg;
SOCKET sock = sp->new_socket;
grpc_winsocket_callback_info *info = &sp->socket->read_info;
grpc_endpoint *ep = NULL;
/* The shutdown sequence is done in two parts. This is the second
part here, acknowledging the IOCP notification, and doing nothing
else, especially not queuing a new accept. */
if (sp->shutting_down) {
GPR_ASSERT(from_iocp);
sp->shutting_down = 0;
gpr_mu_lock(&sp->server->mu);
if (0 == --sp->server->active_ports) {
gpr_cv_broadcast(&sp->server->cv);
}
gpr_mu_unlock(&sp->server->mu);
return;
}
if (from_iocp) {
/* The IOCP notified us of a completed operation. Let's grab the results,
and act accordingly. */
DWORD transfered_bytes = 0;
DWORD flags;
BOOL wsa_success = WSAGetOverlappedResult(sock, &info->overlapped,
&transfered_bytes, FALSE, &flags);
if (!wsa_success) {
char *utf8_message = gpr_format_message(WSAGetLastError());
gpr_log(GPR_ERROR, "on_accept error: %s", utf8_message);
gpr_free(utf8_message);
closesocket(sock);
} else {
ep = grpc_tcp_create(grpc_winsocket_create(sock));
}
} else {
/* If we're not notified from the IOCP, it means we are asked to shutdown.
This will initiate that shutdown. Calling closesocket will trigger an
IOCP notification, that will call this function a second time, from
the IOCP thread. Of course, this only works if the socket was, in fact,
listening. If that's not the case, we'd wait indefinitely. That's a bit
of a degenerate case, but it can happen if you create a server, but
don't start it. So let's support that by recursing once. */
sp->shutting_down = 1;
sp->new_socket = INVALID_SOCKET;
if (sock != INVALID_SOCKET) {
closesocket(sock);
} else {
on_accept(sp, 1);
}
return;
}
/* The only time we should call our callback, is where we successfully
managed to accept a connection, and created an endpoint. */
if (ep) sp->server->cb(sp->server->cb_arg, ep);
/* As we were notified from the IOCP of one and exactly one accept,
the former socked we created has now either been destroy or assigned
to the new connection. We need to create a new one for the next
connection. */
start_accept(sp);
}
bool master_aio::accept_callback(aio_socket_stream* client)
{
return on_accept(client);
}
