void InputService::onEnable()
{
bindings.clear();
bindKey(KEY_UP, sf::Keyboard::W);
bindKey(KEY_LEFT, sf::Keyboard::A);
bindKey(KEY_DOWN, sf::Keyboard::S);
bindKey(KEY_RIGHT, sf::Keyboard::D);
bindKey(KEY_YIELD_CONTROL, sf::Keyboard::Tab);
bindKey(KEY_SPRINT, sf::Keyboard::Space);
bindKey(KEY_EXIT, sf::Keyboard::Escape);
// todo load from config
// check all keys have been registered
if (bindings.left.size() != KEY_UNKNOWN)
{
Logger::logError(format("Expected %1% key bindings, received %2% instead",
_str(KEY_UNKNOWN), _str(bindings.left.size())));
error("Invalid number of key bindings");
}
// listen to input events
auto events = Locator::locate<EventService>();
events->registerListener(this, EVENT_RAW_INPUT_KEY);
events->registerListener(this, EVENT_RAW_INPUT_CLICK);
}
XournalView::XournalView(GtkWidget* parent, Control* control)
{
XOJ_INIT_TYPE(XournalView);
this->control = control;
this->cache = new PdfCache(control->getSettings()->getPdfPageCacheSize());
registerListener(control);
this->widget = gtk_xournal_new(this);
// we need to refer widget here, because wo unref it somwere twice!?
g_object_ref(this->widget);
gtk_table_attach_defaults(GTK_TABLE(parent), this->widget, 1, 2, 0, 1);
gtk_widget_show(this->widget);
this->repaintHandler = new RepaintHandler(this);
this->pagePosition = new PagePositionHandler();
this->viewPages = NULL;
this->viewPagesLen = 0;
this->margin = 75;
this->currentPage = 0;
this->lastSelectedPage = -1;
control->getZoomControl()->addZoomListener(this);
gtk_widget_set_can_default(this->widget, true);
gtk_widget_grab_default(this->widget);
gtk_widget_grab_focus(this->widget);
this->cleanupTimeout = g_timeout_add_seconds(5, (GSourceFunc) clearMemoryTimer, this);
}
std::string ITopicImpl::addMessageListener(impl::BaseEventHandler *topicEventHandler) {
std::auto_ptr<protocol::codec::IAddListenerCodec> addCodec =
std::auto_ptr<protocol::codec::IAddListenerCodec>(
new protocol::codec::TopicAddMessageListenerCodec(getName(), false));
return registerListener(addCodec, topicEventHandler);
}
std::string IListImpl::addItemListener(impl::BaseEventHandler *entryEventHandler, bool includeValue) {
std::auto_ptr<protocol::codec::IAddListenerCodec> addCodec = std::auto_ptr<protocol::codec::IAddListenerCodec>(
new protocol::codec::ListAddListenerCodec(getName(), includeValue,
false));
return registerListener(addCodec, entryEventHandler);
}
SidebarPreviewBase::SidebarPreviewBase(Control* control, GladeGui* gui, SidebarToolbar* toolbar)
: AbstractSidebarPage(control, toolbar)
{
XOJ_INIT_TYPE(SidebarPreviewBase);
this->layoutmanager = new SidebarLayout();
this->cache = new PdfCache(control->getSettings()->getPdfPageCacheSize());
this->iconViewPreview = gtk_layout_new(NULL, NULL);
g_object_ref(this->iconViewPreview);
this->scrollPreview = gtk_scrolled_window_new(NULL, NULL);
g_object_ref(this->scrollPreview);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(this->scrollPreview), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(this->scrollPreview), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(this->scrollPreview), this->iconViewPreview);
gtk_widget_show(this->scrollPreview);
gtk_widget_show(this->iconViewPreview);
registerListener(this->control);
g_signal_connect(this->scrollPreview, "size-allocate", G_CALLBACK(sizeChanged), this);
gtk_widget_show_all(this->scrollPreview);
g_signal_connect(this->iconViewPreview, "draw", G_CALLBACK(Util::paintBackgroundWhite), NULL);
}
void NotificationManager::startNotifyThread(){
if(!isSokcetInited) {
mListener = NULL;
registerListener(new NuCommandListener());
startListener();
isSokcetInited = true;
}
}
//------------------------------------------------------------------------------
DependsBase::DependsBase()
{
auto context = getContext();
if (context)
{
connections_ += context->registerListener(*this);
}
}
CullerComponent::CullerComponent(const CullerComponent& other, Object& newObj, void* newComp)
: PhantomBody (other, newObj),
ContactListener (),
m_type (other.m_type),
m_component (newComp)
{
registerListener(*this);
}
CullerComponent::CullerComponent(Object& object, World& world, const Type type, void* component)
: PhantomBody (object, world, getDummyShape()),
ContactListener (),
m_type (type),
m_component (component)
{
registerListener(*this);
}
SidebarIndexPage::SidebarIndexPage(Control* control) : AbstractSidebarPage(
control)
{
XOJ_INIT_TYPE(SidebarIndexPage);
this->searchTimeout = 0;
this->hasContents = false;
this->treeViewBookmarks = gtk_tree_view_new();
g_object_ref(this->treeViewBookmarks);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeViewBookmarks), true);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeViewBookmarks),
DOCUMENT_LINKS_COLUMN_NAME);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeViewBookmarks),
(GtkTreeViewSearchEqualFunc) treeSearchFunction, this, NULL);
this->scrollBookmarks = gtk_scrolled_window_new(NULL, NULL);
g_object_ref(this->scrollBookmarks);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_SHADOW_IN);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
treeViewBookmarks));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeViewBookmarks), FALSE);
gtk_container_add(GTK_CONTAINER(scrollBookmarks), treeViewBookmarks);
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeViewBookmarks), column);
GtkCellRenderer* renderer = (GtkCellRenderer*) g_object_new(
GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, TRUE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"markup", DOCUMENT_LINKS_COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"text", DOCUMENT_LINKS_COLUMN_PAGE_NUMBER, NULL);
g_object_set(G_OBJECT(renderer), "style", PANGO_STYLE_ITALIC, NULL);
g_signal_connect(treeViewBookmarks, "cursor-changed",
G_CALLBACK(treeBookmarkSelected), this);
gtk_widget_show(this->treeViewBookmarks);
registerListener(control);
}
void PacketReceiver::registerDirectListener(PacketType type, QObject* listener, const char* slot) {
Q_ASSERT_X(listener, "PacketReceiver::registerDirectListener", "No object to register");
Q_ASSERT_X(slot, "PacketReceiver::registerDirectListener", "No slot to register");
bool success = registerListener(type, listener, slot);
if (success) {
QMutexLocker locker(&_directConnectSetMutex);
// if we successfully registered, add this object to the set of objects that are directly connected
_directlyConnectedObjects.insert(listener);
}
}
XletQueues::XletQueues(QWidget *parent)
: XLet(parent),
m_configureWindow(NULL)
{
setTitle(tr("Queues"));
QStringList xletlist;
uint nsecs = 30;
if (b_engine->getConfig().contains("xlet.queues.statsfetchperiod")) {
nsecs = b_engine->getConfig("xlet.queues.statsfetchperiod").toInt();
}
QVBoxLayout *xletLayout = new QVBoxLayout();
setLayout(xletLayout);
xletLayout->setSpacing(0);
registerListener("getqueuesstats");
m_model = new QueuesModel(this);
m_proxyModel = new QueuesSortFilterProxyModel(this);
m_proxyModel->setSourceModel(m_model);
m_proxyModel->updateFilter();
QueuesView *view = new QueuesView(this);
view->setModel(m_proxyModel);
view->hideColumn(QueuesModel::ID);
view->sortByColumn(QueuesModel::NAME, Qt::AscendingOrder);
view->init();
xletLayout->addWidget(view);
QTimer * timer_display = new QTimer(this);
QTimer * timer_request = new QTimer(this);
connect(timer_request, SIGNAL(timeout()), this, SLOT(askForQueueStats()));
connect(timer_display, SIGNAL(timeout()),
m_model, SLOT(increaseWaitTime()));
timer_request->start(nsecs * 1000);
timer_display->start(1000);
connect(m_model, SIGNAL(askForQueueStats()),
this, SLOT(askForQueueStats()));
subscribeToQueuesStats();
}
void handleMessage() {
BYTE name[20] = "";
if (!LMTakeString(&name, sizeof(name))) {
printf("Could not handle message (to long?)\r\n");
return;
}
if (strcmp(name, "reglistener") == 0) {
registerListener();
} else if (strcmp(name, "send") == 0) {
send();
} else if (strcmp(name, "setip") == 0) {
setIp();
} else if (strcmp(name, "saveip") == 0) {
saveIp();
} else if (strcmp(name, "disconnect") == 0) {
Reset();
}
}
Sidebar::Sidebar(GladeGui* gui, Control* control)
{
XOJ_INIT_TYPE(Sidebar);
this->control = control;
this->tbSelectPage = GTK_TOOLBAR(gui->get("tbSelectSidebarPage"));
this->buttonCloseSidebar = gui->get("buttonCloseSidebar");
this->visiblePage = NULL;
this->sidebar = gui->get("sidebarContents");
gtk_widget_set_size_request(sidebar, control->getSettings()->getSidebarWidth(), 100);
this->initPages(sidebar, gui);
gtk_widget_set_visible(GTK_WIDGET(sidebar), control->getSettings()->isSidebarVisible());
registerListener(control);
}
void Logger::enableLocalFile(bool doFile)
{
QMutexLocker lock(&mFileLoggerMutex);
if (doFile)
{
if (fileLogger) return; // No worries
fileLogger = new FileLogListener();
fileLogger->openFile(dir.absoluteFilePath(QString(RN_LOG_FILE_NAME)));
registerListener(fileLogger);
}
else
{
if (!fileLogger) return; // No logger, already disabled
unregisterListener(fileLogger);
delete fileLogger;
}
}
XournalView::XournalView(GtkWidget* parent, Control* control, ScrollHandling* scrollHandling, ZoomGesture* zoomGesture)
: scrollHandling(scrollHandling),
control(control),
zoomGesture(zoomGesture)
{
XOJ_INIT_TYPE(XournalView);
this->cache = new PdfCache(control->getSettings()->getPdfPageCacheSize());
registerListener(control);
InputContext* inputContext = nullptr;
if (this->control->getSettings()->getExperimentalInputSystemEnabled())
{
inputContext = new InputContext(this, scrollHandling);
this->widget = gtk_xournal_new(this, inputContext);
}
else
{
this->widget = gtk_xournal_new_deprecated(this, scrollHandling);
}
// we need to refer widget here, because we unref it somewhere twice!?
g_object_ref(this->widget);
gtk_container_add(GTK_CONTAINER(parent), this->widget);
gtk_widget_show(this->widget);
g_signal_connect(getWidget(), "realize", G_CALLBACK(onRealized), this);
this->repaintHandler = new RepaintHandler(this);
this->handRecognition = new HandRecognition(this->widget, inputContext, control->getSettings());
control->getZoomControl()->addZoomListener(this);
gtk_widget_set_can_default(this->widget, true);
gtk_widget_grab_default(this->widget);
gtk_widget_grab_focus(this->widget);
this->cleanupTimeout = g_timeout_add_seconds(5, (GSourceFunc) clearMemoryTimer, this);
}
History::History(QWidget *parent)
: XLet(parent, tr("History"), ":/images/tab-history.svg"),
m_model(NULL),
m_proxy_model(NULL)
{
this->ui.setupUi(this);
m_model = new HistoryModel(this);
m_proxy_model = new HistorySortFilterProxyModel(this);
m_proxy_model->setSourceModel(m_model);
this->ui.history_table->setModel(m_proxy_model);
this->ui.history_table->sortByColumn(2, Qt::DescendingOrder);
QAction *all_call_action = this->ui.menu->addAction(tr("All calls"));
QAction *sent_call_action = this->ui.menu->addAction(tr("Sent calls"));
QAction *received_call_action = this->ui.menu->addAction(tr("Received calls"));
QAction *missed_call_action = this->ui.menu->addAction(tr("Missed calls"));
connect(all_call_action, SIGNAL(triggered()),
this, SLOT(allCallsMode()));
connect(sent_call_action, SIGNAL(triggered()),
this, SLOT(sentCallsMode()));
connect(received_call_action, SIGNAL(triggered()),
this, SLOT(receivedCallsMode()));
connect(missed_call_action, SIGNAL(triggered()),
this, SLOT(missedCallsMode()));
this->ui.menu->setSelectedAction(0);
connect(b_engine, SIGNAL(settingsChanged()),
this, SLOT(requestHistory()));
connect(this->ui.history_table, SIGNAL(extensionClicked(const QString &)),
b_engine, SLOT(pasteToDial(const QString &)));
registerListener("history");
}
void HandlerList::registerAll(std::vector<RegisteredListener *> listeners)
{
for(RegisteredListener *listener : listeners)
registerListener(listener);
}
bool MachineBridge::start()
{
nsresult rc;
bool launchSucceeded;
uint32_t sessionState, machineState;
/*
* Session checking: check session for first launch or if it is still running
*/
if(session != nsnull)
{
machineState = getState();
if(machineState == MachineState::Starting
|| machineState == MachineState::Running
|| machineState == MachineState::Paused)
{
std::cout << "[" << getName().toStdString() << "] VM is starting/running/paused" << std::endl;
return false;
}
// Try to unlock session, then check if this action succeeded
uint32_t state;
NS_CHECK_AND_DEBUG_ERROR(session, UnlockMachine(), rc); //FIXME
nsresult rc_tmp;
NS_CHECK_AND_DEBUG_ERROR(session, GetState(&state), rc_tmp);
// If Session is not unlocked, VM is still running
if(NS_FAILED(rc) || state != SessionState::Unlocked)
{
std::cout << "[" << getName().toStdString() << "] Session locked!" << std::endl;
return false;
}
}
// Create new session
session = vboxbridge->newSession();
/*
* Launch routine: launch machine and check if it is launched or in starting state
*/
nsXPIDLString type; type.AssignWithConversion("", 0);
nsXPIDLString environment; environment.AssignWithConversion("", 0);
nsCOMPtr<IProgress> progress;
/*
NS_CHECK_AND_DEBUG_ERROR(machine, LockMachine(session, LockType::Shared), rc);
uint32_t state;
nsresult rc_tmp;
NS_CHECK_AND_DEBUG_ERROR(session, GetState(&state), rc_tmp);
if(NS_FAILED(rc) || state != SessionState::Locked)
{
std::cout << "[" << getName().toStdString() << "] Can't lock Session!" << std::endl;
return false;
}
*/
ProgressDialog p(QString::fromUtf8("Avvio macchina ").append(getName()));
p.ui->progressBar->setValue(0);
p.open();
NS_CHECK_AND_DEBUG_ERROR(machine, LaunchVMProcess(session, type, environment, getter_AddRefs(progress)), rc);
if(NS_FAILED(rc))
{
launchSucceeded = false;
std::cout << "[" << getName().toStdString() << "] Cannot launch VM!" << std::endl;
progress = nsnull;
}
else
{
launchSucceeded = true;
PRInt32 resultCode;
PRBool progress_completed;
do
{
uint32_t percent;
progress->GetCompleted(&progress_completed);
progress->GetPercent(&percent);
p.ui->progressBar->setValue(percent);
p.refresh();
usleep(750000);
} while(!progress_completed);
progress->GetResultCode(&resultCode);
if (resultCode != 0) // check success
{
std::cout << "[" << getName().toStdString() << "] Cannot launch VM! Result code: 0x" << std::hex << resultCode << std::dec << std::endl;
return false;
}
registerListener();
}
return launchSucceeded;
}
DataQueryBetaGamma::DataQueryBetaGamma(const ENSDF * ENSDFDatabase, const MassTable * MassTabell, VerbosePrinter * toRegister)
{
registerListener(toRegister);
myENSDF = ENSDFDatabase;
myMassTable = MassTabell;
}
