Macaw/radio
3
0
Fork 0
Code Issues 3 Pull Requests Releases Wiki Activity

initial player stuff

Browse Source
This commit is contained in:
Blue 2018-08-05 00:52:16 +03:00 committed by Юрий Губич
parent 4b60ece582
commit 5100d91a72
38 changed files with 1107 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
corax/CMakeLists.txt
View File

@ -23,6 +23,7 @@ set(SOURCES
)
add_executable(corax ${HEADERS} ${SOURCES})
add_subdirectory(models)
target_link_libraries(corax Qt5::Core)
target_link_libraries(corax Qt5::Network)
@ -31,10 +32,10 @@ target_link_libraries(corax wSocket)
target_link_libraries(corax wDispatcher)
target_link_libraries(corax utils)
target_link_libraries(corax wModel)
target_link_libraries(corax wController)
target_link_libraries(corax wServerUtils)
target_link_libraries(corax wDatabase)
target_link_libraries(corax tag)
target_link_libraries(corax tools)
target_link_libraries(corax coraxModels)
target_link_libraries(corax wServerUtils)
install(TARGETS corax RUNTIME DESTINATION bin)

16
corax/corax.cpp
View File

@ -90,11 +90,11 @@ void Corax::start()
server->listen(8080);
cout << "Registering models..." << endl;
attributes->registerModel(dispatcher, server);
commands->registerModel(dispatcher, server);
attributes->getRegistered(connector);
commands->getRegistered(connector);
for (; beg != end; ++beg) {
beg->second->registerModel(dispatcher, server);
beg->second->getRegistered(connector);
}
cout << "Opening caches..." << endl;
@ -115,11 +115,11 @@ void Corax::stop()
std::map<W::String, ResourceCache*>::iterator end = caches.end();
cout << "Stopping corax..." << endl;
commands->unregisterModel();
attributes->unregisterModel();
commands->getUnregistered();
attributes->getUnregistered();
for (; beg != end; ++beg) {
beg->second->unregisterModel();
beg->second->getUnregistered();
}
server->stop();
@ -169,10 +169,10 @@ void Corax::h_parseDirectory(const W::Event& ev)
if (itr != parsers.end()) {
cout << "directory " << path.toString() << " is already being parsed" << endl;
} else {
const W::Socket& socket = connector->getNodeSocket(W::String(u"Perturabo"));
const W::Socket* socket = connector->getNodeSocket(W::String(u"Perturabo"));
ResourceCache* music = caches.at(W::String(u"music"));
ResourceCache* images = caches.at(W::String(u"images"));
Parser* parser = new Parser(&socket, dispatcher, music, images);
Parser* parser = new Parser(socket, dispatcher, music, images);
parsers.insert(std::make_pair(path, parser));
connect(parser, SIGNAL(serviceMessage(const QString&)), SLOT(onModelServiceMessage(const QString&)));

21
corax/models/CMakeLists.txt Normal file
View File

@ -0,0 +1,21 @@
cmake_minimum_required(VERSION 2.8.12)
project(coraxModels)
find_package(Qt5Core REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOMOC ON)
set(HEADERS
player.h
proxysong.h
)
set(SOURCES
player.cpp
proxysong.cpp
)
add_library(coraxModels STATIC ${HEADERS} ${SOURCES})
target_link_libraries(coraxModels wModel)

121
corax/models/player.cpp Normal file
View File

@ -0,0 +1,121 @@
#include "player.h"
M::Player::Player(const W::Address& address, QObject* parent):
M::Model(address, parent),
controls(),
views(),
playPauseBtn(new M::Button(address + W::Address{u"play"})),
_queueView(new M::List(address + W::Address{u"queueView"})),
_queue(),
current(0)
{
W::Handler* get = W::Handler::create(address + W::Address({u"get"}), this, &M::Player::_h_get);
W::Handler* hqueue = W::Handler::create(address + W::Address({u"queue"}), this, &M::Player::_h_queue);
addHandler(get);
addHandler(hqueue);
playPauseBtn->setLabel(W::String(u"play"));
playPauseBtn->setEnabled(false);
connect(playPauseBtn, SIGNAL(activated()), this, SLOT(onPlayPauseBtn()));
addModel(playPauseBtn);
addModel(_queueView);
controls.insert(std::make_pair(playPause, playPauseBtn->getAddress()));
views.insert(std::make_pair(queue, _queueView->getAddress()));
}
M::Player::~Player()
{
}
void M::Player::set(const W::Object& value)
{
throw 14; //what do you expect here? not implemented, and not sure it ever would be
}
void M::Player::set(W::Object* value)
{
set(*value);
}
M::Model::ModelType M::Player::getType() const
{
return M::Model::player;
}
void M::Player::h_subscribe(const W::Event& ev)
{
M::Model::h_subscribe(ev);
h_get(ev);
}
void M::Player::h_get(const W::Event& ev)
{
W::Vector* ctrls = new W::Vector();
ItemMap::const_iterator citr = controls.begin();
ItemMap::const_iterator cend = controls.end();
for (; citr != cend; ++citr) {
W::Vocabulary* cvc = new W::Vocabulary();
cvc->insert(u"type", new W::Uint64(cend->first));
cvc->insert(u"address", cend->second);
ctrls->push(cvc);
}
W::Vector* vws = new W::Vector();
ItemMap::const_iterator vitr = views.begin();
ItemMap::const_iterator vend = views.end();
for (; vitr != vend; ++vitr) {
W::Vocabulary* vvc = new W::Vocabulary();
vvc->insert(u"type", new W::Uint64(vend->first));
vvc->insert(u"address", vend->second);
vws->push(vvc);
}
W::Vocabulary* res = new W::Vocabulary();
res->insert(u"controls", ctrls);
res->insert(u"views", vws);
response(res, W::Address({u"get"}), ev);
}
void M::Player::onPlayPauseBtn()
{
}
void M::Player::h_queue(const W::Event& ev)
{
const W::Vocabulary& data = static_cast<const W::Vocabulary&>(ev.getData());
const W::Uint64& id = static_cast<const W::Uint64&>(data.at(u"id"));
ProxySong* song = new ProxySong(id, address + W::Address{u"currentPlayback"});
addModel(song);
if (current == 0) {
current = song;
views.insert(std::make_pair(currentPlayback, song->getAddress()));
W::Vocabulary* avc = new W::Vocabulary();
avc->insert(u"type", new W::Uint64(currentPlayback));
avc->insert(u"address", song->getAddress());
W::Vector* add = new W::Vector();
add->push(avc);
W::Vocabulary* res = new W::Vocabulary();
res->insert(u"add", add);
res->insert(u"remove", new W::Vector());
broadcast(res, W::Address{u"viewsChange"});
} else {
_queue.push_back(song);
_queueView->push(song->getAddress());
}
}

60
corax/models/player.h Normal file
View File

@ -0,0 +1,60 @@
#ifndef PLAYER_H
#define PLAYER_H
#include <map>
#include <deque>
#include <wModel/model.h>
#include <wModel/button.h>
#include <wModel/modelstring.h>
#include <wModel/list.h>
#include <wType/vocabulary.h>
#include <wType/vector.h>
#include <wType/address.h>
#include "proxysong.h"
/**
* @todo write docs
*/
namespace M {
class Player : public M::Model {
Q_OBJECT
public:
Player(const W::Address& address, QObject* parent = 0);
~Player();
void set(const W::Object & value) override;
void set(W::Object * value) override;
M::Model::ModelType getType() const override;
enum ItemType {
playPause,
currentPlayback,
queue
};
protected:
void h_subscribe(const W::Event & ev) override;
handler(get);
handler(queue);
private:
typedef std::map<ItemType, const W::Address&> ItemMap;
typedef std::deque<ProxySong*> Queue;
ItemMap controls;
ItemMap views;
M::Button* playPauseBtn;
M::List* _queueView;
Queue _queue;
ProxySong* current;
private slots:
void onPlayPauseBtn();
};
}
#endif // PLAYER_H

135
corax/models/proxysong.cpp Normal file
View File

@ -0,0 +1,135 @@
#include "proxysong.h"
ProxySong::ProxySong(const W::Uint64& p_id, const W::Address& p_address, QObject* parent):
M::Vocabulary(p_address, parent),
songCtrl(new C::Vocabulary(W::Address{u"songs", W::String(p_id.toString())})),
albumCtrl(0),
artistCtrl(0),
fileId(0),
_ready(false)
{
addController(songCtrl, W::String(u"Perturabo"));
connect(songCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), SLOT(onSongNewElement(const W::String&, const W::Object&)));
connect(songCtrl, SIGNAL(removeElement(const W::String&)), SLOT(onSongRemoveElement(const W::String&)));
insert(W::String(u"id"), p_id);
insert(W::String(u"artist"), new W::String(u"undefined"));
insert(W::String(u"album"), new W::String(u"undefined"));
insert(W::String(u"name"), new W::String(u"undefined"));
insert(W::String(u"image"), new W::Uint64(0));
}
bool ProxySong::isReady() const
{
return _ready;
}
ProxySong::~ProxySong()
{
}
void ProxySong::onSongNewElement(const W::String& key, const W::Object& element)
{
if (key == u"name") {
insert(key, element);
} else if (key == u"audio") {
if (_ready) {
_ready = false;
emit notReady();
}
fileId = static_cast<const W::Uint64&>(element);
_ready = true;
emit ready();
} else if (key == u"artist") {
if (artistCtrl != 0) {
removeController(artistCtrl);
disconnect(artistCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), this, SLOT(onArtistNewElement(const W::String&, const W::Object&)));
disconnect(artistCtrl, SIGNAL(removeElement(const W::String&)), this, SLOT(onAtristRemoveElement(const W::String&)));
artistCtrl->deleteLater();
}
const W::Uint64& aid = static_cast<const W::Uint64&>(element);
artistCtrl = new C::Vocabulary(W::Address{u"artists", W::String(aid.toString())});
addController(artistCtrl, W::String(u"Perturabo"));
connect(artistCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), SLOT(onArtistNewElement(const W::String&, const W::Object&)));
connect(artistCtrl, SIGNAL(removeElement(const W::String&)), SLOT(onAtristRemoveElement(const W::String&)));
} else if (key == u"album") {
if (albumCtrl != 0) {
removeController(albumCtrl);
disconnect(albumCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), this, SLOT(onAlbumNewElement(const W::String&, const W::Object&)));
disconnect(albumCtrl, SIGNAL(removeElement(const W::String&)), this, SLOT(onAlbumRemoveElement(const W::String&)));
albumCtrl->deleteLater();
}
const W::Uint64& aid = static_cast<const W::Uint64&>(element);
albumCtrl = new C::Vocabulary(W::Address{u"albums", W::String(aid.toString())});
addController(albumCtrl, W::String(u"Perturabo"));
connect(albumCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), SLOT(onAlbumNewElement(const W::String&, const W::Object&)));
connect(albumCtrl, SIGNAL(removeElement(const W::String&)), SLOT(onAlbumRemoveElement(const W::String&)));
}
}
void ProxySong::onSongRemoveElement(const W::String& key)
{
if (key == u"name") {
insert(key, new W::String(u"undefined"));
} else if (key == u"audio") {
if (_ready) {
_ready = false;
fileId = W::Uint64(0);
emit notReady();
}
} else if (key == u"artist") {
if (artistCtrl != 0) {
removeController(artistCtrl);
disconnect(artistCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), this, SLOT(onArtistNewElement(const W::String&, const W::Object&)));
disconnect(artistCtrl, SIGNAL(removeElement(const W::String&)), this, SLOT(onAtristRemoveElement(const W::String&)));
artistCtrl->deleteLater();
artistCtrl = 0;
}
} else if (key == u"album") {
if (albumCtrl != 0) {
removeController(albumCtrl);
disconnect(albumCtrl, SIGNAL(newElement(const W::String&, const W::Object&)), this, SLOT(onAlbumNewElement(const W::String&, const W::Object&)));
disconnect(albumCtrl, SIGNAL(removeElement(const W::String&)), this, SLOT(onAlbumRemoveElement(const W::String&)));
albumCtrl->deleteLater();
albumCtrl = 0;
}
}
}
void ProxySong::onAlbumNewElement(const W::String& key, const W::Object& element)
{
if (key == u"name") {
insert(W::String(u"album"), element);
} else if (key == u"image") {
insert(key, element);
}
}
void ProxySong::onAlbumRemoveElement(const W::String& key)
{
if (key == u"name") {
insert(W::String(u"album"), new W::String(u"undefined"));
} else if (key == u"image") {
insert(key, new W::Uint64(0));
}
}
void ProxySong::onArtistNewElement(const W::String& key, const W::Object& element)
{
if (key == u"name") {
insert(W::String(u"artist"), element);
}
}
void ProxySong::onArtistRemoveElement(const W::String& key)
{
if (key == u"name") {
insert(W::String(u"artist"), new W::String(u"undefined"));
}
}
const W::Uint64 & ProxySong::getFileId() const
{
return fileId;
}

47
corax/models/proxysong.h Normal file
View File

@ -0,0 +1,47 @@
#ifndef PROXYSONG_H
#define PROXYSONG_H
/**
* @todo write docs
*/
#include <wType/uint64.h>
#include <wType/address.h>
#include <wModel/vocabulary.h>
#include <wController/vocabulary.h>
class ProxySong : public M::Vocabulary {
Q_OBJECT
public:
ProxySong(const W::Uint64& p_id, const W::Address& p_address, QObject* parent = 0);
~ProxySong();
const W::Uint64& getFileId() const;
bool isReady() const;
signals:
void ready();
void notReady();
private:
C::Vocabulary* songCtrl;
C::Vocabulary* albumCtrl;
C::Vocabulary* artistCtrl;
W::Uint64 fileId;
bool _ready;
private slots:
void onSongNewElement(const W::String& key, const W::Object& element);
void onSongRemoveElement(const W::String& key);
void onAlbumNewElement(const W::String& key, const W::Object& element);
void onAlbumRemoveElement(const W::String& key);
void onArtistNewElement(const W::String& key, const W::Object& element);
void onArtistRemoveElement(const W::String& key);
};
#endif // PROXYSONG_H

5
lib/wController/controller.cpp
View File

@ -276,3 +276,8 @@ bool C::Controller::isSubscribed()
{
return subscribed;
}
const W::Address & C::Controller::getAddress() const
{
return address;
}

1
lib/wController/controller.h
View File

@ -40,6 +40,7 @@ namespace C {
void subscribe();
void unsubscribe();
bool isSubscribed();
const W::Address& getAddress() const;
void removeHandler(W::Handler* handler);
void removeController(C::Controller* ctrl);

2
lib/wDatabase/resourcecache.cpp
View File

@ -215,7 +215,7 @@ void ResourceCache::h_subscribeMember(const W::Event& ev)
M::File* modelRecord = M::File::create(readFile(*record), address + lastHops >> 1);
delete record;
addModel(modelRecord);
passToHandler(ev);
passToLocalHandler(ev);
} catch (int err) {
if (err == 3) {
emit serviceMessage(QString("An attempt to create and subscribe record model in resourcecache, but it is not found. Event: ") + ev.toString().c_str());

6
lib/wModel/CMakeLists.txt
View File

@ -14,6 +14,7 @@ set(HEADERS
attributes.h
icatalogue.h
catalogue.h
button.h
file/file.h
)
@ -25,12 +26,13 @@ set(SOURCES
attributes.cpp
icatalogue.cpp
catalogue.cpp
button.cpp
file/file.cpp
)
add_library(wModel STATIC ${HEADERS} ${SOURCES})
target_link_libraries(wModel Qt5::Core)
target_link_libraries(wModel wSocket)
target_link_libraries(wModel wDispatcher)
target_link_libraries(wModel wServerUtils)
target_link_libraries(wModel wType)
target_link_libraries(wModel wController)

113
lib/wModel/button.cpp Normal file
View File

@ -0,0 +1,113 @@
#include "button.h"
M::Button::Button(const W::Address& address, QObject* parent):
M::Model(address, parent),
enabled(true),
hasImage(false),
hasLabel(false),
imageName(0),
label(0)
{
W::Handler* get = W::Handler::create(address + W::Address({u"get"}), this, &M::Button::_h_get);
W::Handler* activate = W::Handler::create(address + W::Address({u"activate"}), this, &M::Button::_h_activate);
addHandler(get);
addHandler(activate);
}
M::Button::~Button()
{
if (hasImage) {
delete imageName;
}
}
void M::Button::setImage(const W::String& p_image)
{
if (hasImage) {
if (*imageName != p_image) {
imageName = static_cast<W::String*>(p_image.copy());
W::Vocabulary* vc = new W::Vocabulary();
vc->insert(u"image", p_image);
broadcast(vc, W::Address{u"changeImage"});
}
} else {
imageName = static_cast<W::String*>(p_image.copy());
hasImage = true;
W::Vocabulary* vc = new W::Vocabulary();
vc->insert(u"image", p_image);
broadcast(vc, W::Address{u"setImage"});
}
hasImage = true;
}
void M::Button::setEnabled(bool p_enabled)
{
if (enabled != p_enabled) {
enabled = p_enabled;
W::Vocabulary* vc = new W::Vocabulary();
vc->insert(u"enable", new W::Boolean(enabled));
broadcast(vc, W::Address{u"setEnabled"});
}
}
void M::Button::setLabel(const W::String& p_label)
{
if (hasLabel) {
label->set(p_label);
} else {
label = new M::String(p_label, address + W::Address{u"label"});
addModel(label);
W::Vocabulary* vc = new W::Vocabulary();
vc->insert(u"hasLabel", new W::Boolean(true));
vc->insert(u"label", label->getAddress());
broadcast(vc, W::Address{u"setLabel"});
hasLabel = true;
}
}
void M::Button::h_subscribe(const W::Event& ev)
{
M::Model::h_subscribe(ev);
h_get(ev);
}
void M::Button::h_get(const W::Event& ev)
{
W::Vocabulary* vc = new W::Vocabulary();
vc->insert(u"hasImage", new W::Boolean(hasImage));
if (hasImage) {
vc->insert(u"image", imageName->copy());
}
vc->insert(u"hasLabel", new W::Boolean(hasLabel));
if (hasLabel) {
vc->insert(u"label", label->getAddress());
}
vc->insert(u"enabled", new W::Boolean(enabled));
response(vc, W::Address({u"get"}), ev);
}
void M::Button::h_activate(const W::Event& ev)
{
if (enabled) {
emit activated();
}
}
M::Model::ModelType M::Button::getType() const
{
return M::Model::button;
}
void M::Button::set(const W::Object& value)
{
throw 14; //what do you expect here? not implemented, and not sure it ever would be
}
void M::Button::set(W::Object* value)
{
set(*value);
}

52
lib/wModel/button.h Normal file
View File

@ -0,0 +1,52 @@
#ifndef BUTTON_H
#define BUTTON_H
#include <wModel/model.h>
#include <wModel/modelstring.h>
#include <wDispatcher/handler.h>
#include <wType/address.h>
#include <wType/event.h>
#include <wType/vocabulary.h>
#include <wType/boolean.h>
/**
* @todo write docs
*/
namespace M {
class Button : public Model {
Q_OBJECT
public:
Button(const W::Address& address, QObject* parent = 0);
~Button();
void setImage(const W::String& p_image);
void setLabel(const W::String& p_label);
void setEnabled(bool p_enabled);
M::Model::ModelType getType() const override;
void set(const W::Object & value) override;
void set(W::Object * value) override;
signals:
void activated() const;
protected:
void h_subscribe(const W::Event & ev) override;
handler(get);
handler(activate);
protected:
bool enabled;
bool hasImage;
bool hasLabel;
W::String* imageName;
M::String* label;
};
}
#endif // BUTTON_H

112
lib/wModel/model.cpp
View File

@ -5,12 +5,12 @@ M::Model::Model(const W::Address p_address, QObject* parent):
address(p_address),
registered(false),
subscribers(new Map()),
dispatcher(0),
server(0),
connector(0),
subscribersCount(0),
handlers(new HList()),
properties(new W::Vector()),
models(new MList())
models(new MList()),
controllers(new Controllers())
{
W::Handler* subscribe = W::Handler::create(address + W::Address({u"subscribe"}), this, &M::Model::_h_subscribe);
W::Handler* unsubscribe = W::Handler::create(address + W::Address({u"unsubscribe"}), this, &M::Model::_h_unsubscribe);
@ -21,7 +21,7 @@ M::Model::Model(const W::Address p_address, QObject* parent):
M::Model::~Model()
{
if (registered) {
unregisterModel();
getUnregistered();
}
MList::iterator itr = models->begin();
@ -37,11 +37,19 @@ M::Model::~Model()
for (; hItr != hEnd; ++hItr) {
delete *hItr;
}
Controllers::iterator cItr = controllers->begin();
Controllers::iterator cEnd = controllers->end();
for (; cItr != cEnd; ++cItr) {
delete cItr->first;
}
delete subscribers;
delete properties;
delete handlers;
delete models;
delete controllers;
}
void M::Model::addModel(M::Model* model)
@ -49,7 +57,7 @@ void M::Model::addModel(M::Model* model)
models->push_back(model);
connect(model, SIGNAL(serviceMessage(const QString&)), SIGNAL(serviceMessage(const QString&)));
if (registered) {
model->registerModel(dispatcher, server);
model->getRegistered(connector);
}
}
@ -57,7 +65,7 @@ void M::Model::addHandler(W::Handler* handler)
{
handlers->push_back(handler);
if (registered) {
dispatcher->registerHandler(handler);
connector->registerHandler(handler);
}
}
@ -83,21 +91,20 @@ W::Address M::Model::getAddress() const
}
void M::Model::registerModel(W::Dispatcher* dp, W::Server* srv)
void M::Model::getRegistered(U::Connector* cn)
{
if (registered) {
emit serviceMessage(QString("Model ") + address.toString().c_str() + " is already registered");
throw 1;
} else {
dispatcher = dp;
server = srv;
connector = cn;
MList::iterator itr = models->begin();
MList::iterator end = models->end();
for (; itr != end; ++itr) {
M::Model* model = *itr;
model->registerModel(dispatcher, server);
model->getRegistered(connector);
}
HList::iterator hItr = handlers->begin();
@ -105,14 +112,21 @@ void M::Model::registerModel(W::Dispatcher* dp, W::Server* srv)
for (; hItr != hEnd; ++hItr) {
W::Handler* handler = *hItr;
dispatcher->registerHandler(handler);
connector->registerHandler(handler);
}
Controllers::iterator cItr = controllers->begin();
Controllers::iterator cEnd = controllers->end();
for (; cItr != cEnd; ++cItr) {
connector->registerController(cItr->first, cItr->second);
}
registered = true;
}
}
void M::Model::unregisterModel()
void M::Model::getUnregistered()
{
if (!registered) {
emit serviceMessage(QString("Model ") + address.toString().c_str() + " is not registered");
@ -123,7 +137,7 @@ void M::Model::unregisterModel()
for (; itr != end; ++itr) {
Model* model = *itr;
model->unregisterModel();
model->getUnregistered();
}
HList::iterator hItr = handlers->begin();
@ -131,21 +145,27 @@ void M::Model::unregisterModel()
for (; hItr != hEnd; ++hItr) {
W::Handler* handler = *hItr;
dispatcher->unregisterHandler(handler);
connector->unregisterHandler(handler);
}
Map::iterator sItr = subscribers->begin();
Map::iterator sEnd = subscribers->end();
for (; sItr != sEnd; ++sItr) {
const W::Socket& socket = server->getConnection(sItr->first);
disconnect(&socket, SIGNAL(disconnected()), this, SLOT(onSocketDisconnected()));
const W::Socket* socket = connector->getConnection(sItr->first);
disconnect(socket, SIGNAL(disconnected()), this, SLOT(onSocketDisconnected()));
}
subscribers->clear();
subscribersCount = 0;
dispatcher = 0;
server = 0;
Controllers::iterator cItr = controllers->begin();
Controllers::iterator cEnd = controllers->end();
for (; cItr != cEnd; ++cItr) {
connector->unregisterController(cItr->first, cItr->second);
}
connector = 0;
registered = false;
}
@ -162,7 +182,6 @@ void M::Model::h_subscribe(const W::Event& ev)
params = static_cast<const W::Vocabulary&>(vc.at(u"params"));
}
Map::iterator sItr = subscribers->find(id);
if (sItr == subscribers->end()) {
@ -171,8 +190,8 @@ void M::Model::h_subscribe(const W::Event& ev)
emit serviceMessage(QString("Model ") + address.toString().c_str() + ": something completely wrong happened");
throw 3;
}
const W::Socket& socket = server->getConnection(id);
connect(&socket, SIGNAL(disconnected()), this, SLOT(onSocketDisconnected()));
const W::Socket* socket = connector->getConnection(id);
connect(socket, SIGNAL(disconnected()), this, SLOT(onSocketDisconnected()));
sItr = pair.first;
}
SMap::const_iterator oItr = sItr->second.find(source);
@ -238,8 +257,8 @@ void M::Model::h_unsubscribe(const W::Event& ev)
smap.erase(sItr);
if (smap.size() == 0) {
const W::Socket& socket = server->getConnection(itr->first);
disconnect(&socket, SIGNAL(disconnected()), this, SLOT(onSocketDisconnected()));
const W::Socket* socket = connector->getConnection(itr->first);
disconnect(socket, SIGNAL(disconnected()), this, SLOT(onSocketDisconnected()));
subscribers->erase(itr);
}
--subscribersCount;
@ -256,7 +275,7 @@ void M::Model::send(W::Vocabulary* vc, const W::Address& destination, uint64_t c
}
W::Event ev(destination, vc);
ev.setSenderId(connectionId);
server->getConnection(connectionId).send(ev);
connector->getConnection(connectionId)->send(ev);
}
void M::Model::response(W::Vocabulary* vc, const W::Address& handlerAddress, const W::Event& src)
@ -272,7 +291,7 @@ void M::Model::response(W::Vocabulary* vc, const W::Address& handlerAddress, con
W::Event ev(source + handlerAddress, vc);
ev.setSenderId(id);
server->getConnection(id).send(ev);
connector->getConnection(id)->send(ev);
}
void M::Model::fakeResponse(W::Vocabulary* vc, const W::Address& handlerAddress, const W::Address& sourceAddress, const W::Event& src)
@ -288,7 +307,7 @@ void M::Model::fakeResponse(W::Vocabulary* vc, const W::Address& handlerAddress,
W::Event ev(source + handlerAddress, vc);
ev.setSenderId(id);
server->getConnection(id).send(ev);
connector->getConnection(id)->send(ev);
}
void M::Model::broadcast(W::Vocabulary* vc, const W::Address& handlerAddress)
@ -307,7 +326,7 @@ void M::Model::broadcast(W::Vocabulary* vc, const W::Address& handlerAddress)
for (;oItr != oEnd; ++oItr) {
W::Event ev(oItr->first + handlerAddress, vc->copy());
ev.setSenderId(itr->first);
server->getConnection(itr->first).send(ev);
connector->getConnection(itr->first)->send(ev);
}
}
delete vc;
@ -317,23 +336,54 @@ void M::Model::removeHandler(W::Handler* handler)
{
handlers->erase(handler);
if (registered) {
dispatcher->unregisterHandler(handler);
connector->unregisterHandler(handler);
}
}
void M::Model::removeModel(M::Model* model)
{
models->erase(model);
disconnect(model, SIGNAL(serviceMessage(const QString&)), this, SIGNAL(serviceMessage(const QString&)));
if (registered) {
model->unregisterModel();
model->getUnregistered();
}
}
void M::Model::passToHandler(const W::Event& event) const
void M::Model::passToLocalHandler(const W::Event& event) const
{
if (registered) {
dispatcher->pass(event);
connector->passThroughDispatcher(event);
} else {
emit serviceMessage(QString("An attempt to pass event to dispatcher from unregistered model\nModel address ") + address.toString().c_str());
}
}
void M::Model::addController(C::Controller* ctrl, const W::String& nodeName)
{
Controllers::const_iterator itr = controllers->find(ctrl);
if (itr != controllers->end()) {
emit serviceMessage(QString("An attempt to add controller ") + ctrl->getAddress().toString().c_str() + QString(" for the second time in model ") + address.toString().c_str());
throw 9;
}
controllers->insert(std::make_pair(ctrl, nodeName));
connect(ctrl, SIGNAL(serviceMessage(const QString&)), SIGNAL(serviceMessage(const QString&)));
if (registered) {
connector->registerController(ctrl, nodeName);;
}
}
void M::Model::removeController(C::Controller* ctrl)
{
Controllers::const_iterator itr = controllers->find(ctrl);
if (itr == controllers->end()) {
emit serviceMessage(QString("An attempt to remove absent controller ") + ctrl->getAddress().toString().c_str() + QString(" from the model ") + address.toString().c_str());
throw 10;
}
disconnect(ctrl, SIGNAL(serviceMessage(const QString&)), this, SIGNAL(serviceMessage(const QString&)));
if (registered) {
connector->unregisterController(itr->first, itr->second);
}
controllers->erase(itr);
}

24
lib/wModel/model.h
View File

@ -13,10 +13,10 @@
#include <wType/event.h>
#include <wType/string.h>
#include <wSocket/socket.h>
#include <wSocket/server.h>
#include <wDispatcher/dispatcher.h>
#include <wDispatcher/handler.h>
#include <wContainer/order.h>
#include <wServerUtils/connector.h>
#include <wController/controller.h>
namespace M {
@ -29,10 +29,15 @@ namespace M {
list,
vocabulary,
catalogue,
image,
button,
model,
attributes = 50,
file,
resourceCache
resourceCache,
player = 107
};
Model(const W::Address p_address, QObject* parent = 0);
@ -46,13 +51,15 @@ namespace M {
void addModel(M::Model* model);
void addHandler(W::Handler* handler);
void addProperty(const W::String& value, const W::String& name);
void addController(C::Controller* ctrl, const W::String& nodeName);
W::Address getAddress() const;
void registerModel(W::Dispatcher* dp, W::Server* srv);
void unregisterModel();
void getRegistered(U::Connector* connector);
void getUnregistered();
void removeHandler(W::Handler* handler);
void removeModel(M::Model* model);
void passToHandler(const W::Event& event) const;
void removeController(C::Controller* ctrl);
void passToLocalHandler(const W::Event& event) const;
signals:
void serviceMessage(const QString& msg) const;
@ -76,13 +83,14 @@ namespace M {
private:
typedef W::Order<W::Handler*> HList;
typedef W::Order<M::Model*> MList;
typedef std::map<C::Controller*, W::String> Controllers;
W::Dispatcher* dispatcher;
W::Server* server;
U::Connector* connector;
uint64_t subscribersCount;
HList* handlers;
W::Vector* properties;
MList* models;
Controllers* controllers;
private slots:
void onSocketDisconnected();

3
lib/wModel/vocabulary.h
View File

@ -12,8 +12,7 @@
namespace M {
class ICatalogue;
class Vocabulary : public M::Model
{
class Vocabulary : public M::Model {
friend class ICatalogue;
public:
Vocabulary(const W::Address p_address, QObject* parent = 0);

94
lib/wServerUtils/connector.cpp
View File

@ -1,4 +1,5 @@
#include "connector.h"
#include "commands.h"
U::Connector::Connector(W::Dispatcher* dp, W::Server* srv, U::Commands* cmds, QObject* parent):
QObject(parent),
@ -6,7 +7,8 @@ U::Connector::Connector(W::Dispatcher* dp, W::Server* srv, U::Commands* cmds, QO
server(srv),
commands(cmds),
nodes(),
ignoredNodes()
ignoredNodes(),
controllers()
{
connect(server, SIGNAL(newConnection(const W::Socket&)), SLOT(onNewConnection(const W::Socket&)));
connect(server, SIGNAL(closedConnection(const W::Socket&)), SLOT(onClosedConnection(const W::Socket&)));
@ -30,6 +32,17 @@ U::Connector::~Connector()
for (; itr != end; ++itr) {
commands->removeCommand(dc + itr->first);
}
std::multimap<W::String, C::Controller*>::const_iterator cbeg = controllers.begin();
std::multimap<W::String, C::Controller*>::const_iterator cend = controllers.end();
for (; cbeg != cend; ++cbeg) {
C::Controller* ctrl = cbeg->second;
if (ctrl->isSubscribed()) {
ctrl->unsubscribe();
ctrl->unregisterController();
}
}
}
void U::Connector::addIgnoredNode(const W::String& name)
@ -43,7 +56,7 @@ void U::Connector::sendTo(const W::String& name, const W::Event& event)
if (itr != nodes.end()) {
throw new NodeAccessError(name);
} else {
server->getConnection(itr->second).send(event);
server->getConnection(itr->second)->send(event);
}
}
@ -69,6 +82,14 @@ void U::Connector::onNewConnection(const W::Socket& socket)
emit serviceMessage(QString("New connection, id: ") + socket.getId().toString().c_str());
connect(&socket, SIGNAL(message(const W::Event&)), dispatcher, SLOT(pass(const W::Event&)));
std::multimap<W::String, C::Controller*>::const_iterator beg = controllers.lower_bound(name);
std::multimap<W::String, C::Controller*>::const_iterator end = controllers.upper_bound(name);
for (; beg != end; ++beg) {
beg->second->registerController(dispatcher, &socket);
beg->second->subscribe();
}
emit nodeConnected(name);
}
} else {
@ -90,6 +111,14 @@ void U::Connector::onClosedConnection(const W::Socket& socket)
if (ign == ignoredNodes.end()) {
Map::const_iterator itr = nodes.find(name);
if (itr != nodes.end()) {
std::multimap<W::String, C::Controller*>::const_iterator beg = controllers.lower_bound(name);
std::multimap<W::String, C::Controller*>::const_iterator end = controllers.upper_bound(name);
for (; beg != end; ++beg) {
beg->second->unsubscribe();
beg->second->unregisterController();
}
emit nodeDisconnected(name);
commands->removeCommand(W::String(u"disconnect") + name);
nodes.erase(itr);
@ -114,7 +143,7 @@ void U::Connector::h_disconnect(const W::Event& ev)
server->closeConnection(itr->second);
}
const W::Socket& U::Connector::getNodeSocket(const W::String& name)
const W::Socket* U::Connector::getNodeSocket(const W::String& name)
{
Map::const_iterator itr = nodes.find(name);
if (itr == nodes.end()) {
@ -122,3 +151,62 @@ const W::Socket& U::Connector::getNodeSocket(const W::String& name)
}
return server->getConnection(itr->second);
}
void U::Connector::registerHandler(W::Handler* handler)
{
dispatcher->registerHandler(handler);
}
void U::Connector::unregisterHandler(W::Handler* handler)
{
dispatcher->unregisterHandler(handler);
}
const W::Socket * U::Connector::getConnection(uint64_t p_id) const
{
return server->getConnection(p_id);
}
void U::Connector::passThroughDispatcher(const W::Event& ev) const
{
dispatcher->pass(ev);
}
void U::Connector::registerController(C::Controller* ctrl, const W::String& node)
{
std::set<W::String>::const_iterator iitr = ignoredNodes.find(node);
if (iitr != ignoredNodes.end()) {
throw 3; //this means you're trying to receive something from one of ignored nodes, which never going to be handled in connector, most probably it's a mistake
}
controllers.insert(std::make_pair(node, ctrl));
Map::const_iterator itr = nodes.find(node);
if (itr != nodes.end()) {
ctrl->registerController(dispatcher, server->getConnection(itr->second));
ctrl->subscribe(); //let's say I always need them subscribed, for now at least
}
}
void U::Connector::unregisterController(C::Controller* ctrl, const W::String& node)
{
bool found = false;
std::multimap<W::String, C::Controller*>::const_iterator beg = controllers.lower_bound(node);
std::multimap<W::String, C::Controller*>::const_iterator end = controllers.upper_bound(node);
for (; beg != end; ++beg) {
if (beg->second == ctrl) {
found = true; //TODO make a proper way to store 'em
break;
}
}
if (!found) {
throw 4;
}
if (ctrl->isSubscribed()) {
ctrl->unsubscribe();
ctrl->unregisterController();
}
controllers.erase(beg);
}

16
lib/wServerUtils/connector.h
View File

@ -1,11 +1,14 @@
#ifndef CONNECTOR_H
#define CONNECTOR_H
#include <utils/defines.h>
#include <QtCore/QObject>
#include <map>
#include <set>
#include <wDispatcher/dispatcher.h>
#include <wDispatcher/handler.h>
#include <wSocket/socket.h>
#include <wSocket/server.h>
@ -16,9 +19,11 @@
#include <utils/exception.h>
#include "commands.h"
#include <wController/controller.h>
namespace U {
class Commands;
class Connector : public QObject
{
Q_OBJECT
@ -29,7 +34,13 @@ namespace U {
void addIgnoredNode(const W::String& name);
void sendTo(const W::String& name, const W::Event& event);
const W::Socket& getNodeSocket(const W::String& name);
const W::Socket* getNodeSocket(const W::String& name);
void registerHandler(W::Handler* handler);
void unregisterHandler(W::Handler* handler);
const W::Socket* getConnection(uint64_t p_id) const;
void passThroughDispatcher(const W::Event& ev) const;
void registerController(C::Controller* ctrl, const W::String& node);
void unregisterController(C::Controller* ctrl, const W::String& node);
signals:
void serviceMessage(const QString& msg);
@ -42,6 +53,7 @@ namespace U {
U::Commands* commands;
Map nodes;
std::set<W::String> ignoredNodes;
std::multimap<W::String, C::Controller*> controllers;
protected:
handler(connect);

4
lib/wSocket/server.cpp
View File

@ -44,14 +44,14 @@ void W::Server::stop()
}
}
const W::Socket& W::Server::getConnection(uint64_t p_id) const
const W::Socket* W::Server::getConnection(uint64_t p_id) const
{
std::map<uint64_t, Socket*>::const_iterator itr = connections.find(p_id);
if (itr == connections.end()) {
throw new SocketAccessError();
}
return *(itr->second);
return itr->second;
}
uint64_t W::Server::getConnectionsCount() const

2
lib/wSocket/server.h
View File

@ -27,7 +27,7 @@ namespace W
void listen(uint16_t port);
void stop();
const Socket& getConnection(uint64_t p_id) const;
const Socket* getConnection(uint64_t p_id) const;
uint64_t getConnectionsCount() const;
void closeConnection(uint64_t p_id);
void openConnection(const String& addr, const Uint64& port);

2
lib/wType/object.cpp
View File

@ -102,5 +102,7 @@ W::Object::StdStr W::Object::getTypeName(W::Object::objectType type)
case blob:
return "Blob";
}
throw 5;
}

69
libjs/wController/button.js Normal file
View File

@ -0,0 +1,69 @@
"use strict";
var Controller = require("./controller");
var String = require("./string");
var Vocabulary = require("../wType/vocabulary");
var Button = Controller.inherit({
"className": "Button",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.enabled = false;
this.hasLabel = false;
this.addHandler("get");
this.addHandler("setLabel");
this.addHandler("setImage");
this.addHandler("setEnabled");
this.addHandler("changeImage");
},
"destructor": function() {
Controller.fn.destructor.call(this);
},
"activate": function() {
if (this.enabled) {
this.send(new Vocabulary, "activate");
}
},
"_h_changeImage": function(ev) {
},
"_h_get": function(ev) {
this._h_setLabel(ev);
this._h_setImage(ev);
this._h_setEnabled(ev);
},
"_h_setEnabled": function(ev) {
var data = ev.getData();
var enabled = data.at("enabled").valueOf();
if (this.enabled !== enabled) {
this.enabled = enabled;
this.trigger("setEnabled", this.enabled);
}
},
"_h_setLabel": function(ev) {
var data = ev.getData();
var hasLabel = data.at("hasLabel").valueOf();
if (hasLabel !== this.hasLabel) {
this.hasLabel = hasLabel;
if (hasLabel) {
this.label = new String(data.at("label").clone());
this.addController(this.label);
this.trigger("setLabel", true, this.label);
} else {
this.trigger("setLabel", false);
this.removeController(this.label);
this.label.destructor();
}
}
},
"_h_setImage": function(ev) {
}
});
module.exports = Button;

23
libjs/wController/controller.js
View File

@ -328,8 +328,10 @@ Controller.ModelType = {
String: 0,
List: 1,
Vocabulary: 2,
Image: 3,
Controller: 4,
Catalogue: 3,
Image: 4,
Button: 5,
Controller: 6,
Attributes: 50,
@ -339,15 +341,18 @@ Controller.ModelType = {
PageStorage: 103,
PanesList: 104,
Theme: 105,
ThemeStorage: 106
ThemeStorage: 106,
Player: 107
};
Controller.ReversedModelType = {
"0": "String",
"1": "List",
"2": "Vocabulary",
"3": "Image",
"4": "Controller",
"3": "Catalogue",
"4": "Image",
"5": "Button",
"6": "Controller",
"50": "Attributes",
@ -357,7 +362,8 @@ Controller.ReversedModelType = {
"103": "PageStorage",
"104": "PanesList",
"105": "Theme",
"106": "ThemeStorage"
"106": "ThemeStorage",
"107": "Player"
};
Controller.ModelTypesPaths = {
@ -372,7 +378,10 @@ Controller.ModelTypesPaths = {
PanesList: "./panesList", //resolve as dependency
Theme: "./theme", //resolve as dependency
ThemeStorage: "./themeStorage", //resolve as dependency
Image: "./image" //resolve as dependency
Image: "./image", //resolve as dependency
Button: "./button", //resolve as dependency
Catalogue: "./catalogue", //resolve as dependency
Player: "./player" //resolve as dependency
};
Controller.constructors = {

6
libjs/wController/link.js
View File

@ -10,16 +10,12 @@ var Link = Controller.inherit({
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
var hop = new Address(["label"]);
this.targetAddress = new Address([]);
this.label = new String(addr['+'](hop));
this.addController(this.label);
this.addHandler("get");
hop.destructor();
},
"destructor": function() {
this.targetAddress.destructor();
@ -35,4 +31,6 @@ var Link = Controller.inherit({
}
});
var hop = new Address(["label"]);
module.exports = Link;

1
libjs/wModel/CMakeLists.txt
View File

@ -13,5 +13,6 @@ configure_file(themeStorage.js themeStorage.js)
configure_file(vocabulary.js vocabulary.js)
configure_file(attributes.js attributes.js)
configure_file(image.js image.js)
configure_file(button.js button.js)
add_subdirectory(proxy)

90
libjs/wModel/button.js Normal file
View File

@ -0,0 +1,90 @@
"use strict";
var Model = require("./model");
var ModelString = require("./string");
var Vocabulary = require("../wType/vocabulary");
var Boolean = require("../wType/boolean");
var Address = require("../wType/address");
var String = require("../wType/string");
var Button = Model.inherit({
"className": "Button",
"constructor": function(address) {
Model.fn.constructor.call(this, address);
this._enabled = true;
this._hasImage = false;
this._hasLabel =false;
this._imageName = undefined;
this._label = undefined;
this.addHandler("get");
this.addHandler("activate");
},
"setImage": function(name) {
if (this._hasImage) {
if (this._imageName !== name) {
this._image = name;
var vc = new Vocabulary();
vc.insert("image", new String(this._imageName));
this.broadcast(vc, "changeImage");
}
} else {
this._image = name;
this._hasImage = true;
var vc = new Vocabulary();
vc.insert("image", new String(this._imageName));
this.broadcast(vc, "setImage");
}
},
"setEnabled": function(enabled) {
if (enabled !== this._enabled) {
this._enabled = enabled;
var vc = new Vocabulary();
vc.insert("enabled", new Boolean(this._enabled));
this.broadcast(vc, "setEnabled");
}
},
"setLabel": function(text) {
if (this._hasLabel) {
this._label.set(text);
} else {
this._label = new ModelString(this._address["+"](labelHop), text);
this.addModel(this._label);
var vc = new Vocabulary();
vc.insert("hasLabel", new Boolean(true));
vc.insert("label", this._label.getAddress());
this.broadcast(vc, "setLabel");
this._hasLabel = true;
}
},
"_h_subscribe": function(ev) {
Model.fn._h_subscribe.call(this, ev);
this._h_get(ev);
},
"_h_get": function(ev) {
var vc = new Vocabulary();
vc.insert("hasImage", new Boolean(this._hasImage));
if (this._hasImage) {
vc.insert("image", new String(this._imageName));
}
vc.insert("hasLabel", new Boolean(this._hasLabel));
if (this._hasLabel) {
vc.insert("label", this._label.getAddress());
}
vc.insert("enabled", new Boolean(this._enabled));
this.response(vc, "get", ev);
},
"_h_activate": function() {
if (this._enabled) {
this.trigger("activated");
}
}
});
var labelHop = new Address(["label"]);
module.exports = Button;

9
libjs/wModel/model.js
View File

@ -299,8 +299,10 @@ Model.ModelType = {
String: 0,
List: 1,
Vocabulary: 2,
Image: 3,
Model: 4,
//Catalogue: 3,
Image: 4,
Button: 5,
Model: 6,
Attributes: 50,
@ -310,7 +312,8 @@ Model.ModelType = {
PageStorage: 103,
PanesList: 104,
Theme: 105,
ThemeStorage: 106
ThemeStorage: 106,
Player: 107
};
module.exports = Model;

4
lorgar/css/main.css
View File

@ -45,3 +45,7 @@ div.dragging .draggable {
cursor: -moz-grabbing;
cursor: grabbing;
}
.disabled {
opacity: 0.7;
}

1
lorgar/lib/wController/CMakeLists.txt
View File

@ -17,3 +17,4 @@ add_jslib(wController/localModel.js lib/wController/localModel ${LORGAR_DIR} bro
add_jslib(wController/imagePane.js lib/wController/imagePane ${LORGAR_DIR} browser)
add_jslib(wController/file/file.js lib/wController/file/file ${LORGAR_DIR} browser)
add_jslib(wController/image.js lib/wController/image ${LORGAR_DIR} browser)
add_jslib(wController/button.js lib/wController/button ${LORGAR_DIR} browser)

4
lorgar/main.js
View File

@ -36,8 +36,8 @@
}
}
Controller.initialize(["String", "List", "Vocabulary", "Page", "PanesList", "Link", "Image"], waiter.check.bind(waiter, "controllers"));
View.initialize(["Label", "Page", "PanesList", "Nav", "Image"], waiter.check.bind(waiter, "views"));
Controller.initialize(["String", "List", "Vocabulary", "Page", "PanesList", "Link", "Image", "Button"], waiter.check.bind(waiter, "controllers"));
View.initialize(["Label", "Page", "PanesList", "Nav", "Image", "Button"], waiter.check.bind(waiter, "views"));
var test = new Test();
test.run();

1
lorgar/views/CMakeLists.txt
View File

@ -11,5 +11,6 @@ configure_file(mainLayout.js mainLayout.js)
configure_file(page.js page.js)
configure_file(pane.js pane.js)
configure_file(image.js image.js)
configure_file(button.js button.js)
add_subdirectory(helpers)

95
lorgar/views/button.js Normal file
View File

@ -0,0 +1,95 @@
"use strict";
(function() {
var moduleName = "views/button";
var deps = [];
deps.push("views/layout");
deps.push("views/label");
define(moduleName, deps, function() {
var Layout = require("views/layout");
var Label = require("views/label");
var Button = Layout.inherit({
"className": "Button",
"constructor": function(controller, options) {
var base = {
padding: 5
};
W.extend(base, options)
Layout.fn.constructor.call(this, controller, base);
this.addClass("hoverable");
this._enabled = true;
this._hasLabel = false;
this._e.addEventListener("click", this._onClick.bind(this), false);
controller.on("setEnabled", this._onSetEnabled, this);
controller.on("setLabel", this._onSetLabel, this);
},
"destructor": function() {
this._f.off("setEnabled", this._onSetEnabled, this);
this._f.off("setLabel", this._onSetLabel, this);
Layout.fn.destructor.call(this);
},
"append": function(child, aligment, index) {
this._updateLimits();
Layout.fn.append.call(this, child, aligment, index);
},
"_onChildChangeLimits": function(child) {
this._updateLimits();
Layout.fn._onChildChangeLimits.call(this, child);
},
"_onClick": function() {
if (this._enabled) {
this._f.activate();
}
},
"_onSetEnabled": function(enabled) {
if (this._enabled !== enabled) {
this._enabled = enabled;
if (this._enabled) {
this.addClass("hoverable");
this.removeClass("disabled");
} else {
this.removeClass("hoverable");
this.addClass("disabled");
}
}
},
"_onSetLabel": function(hasLabel, label) {
if (this._hasLabel !== hasLabel) {
this._hasLabel = hasLabel;
if (this._hasLabel) {
this._label = new Label(label);
this.append(this._label, Layout.Aligment.CenterCenter);
} else {
this._label.destructor();
delete this._label();
}
}
},
"_updateLimits": function() {
var minWidth = this._o.padding * 2;
var maxWidth = this._o.padding * 2;
var minHeight = this._o.padding * 2;
var maxHeight = this._o.padding * 2;
if (this._hasLabel) {
minWidth += this._label._o.minWidth;
minHeight += this._label._o.minHeight;
maxWidth += this._label._o.maxWidth;
maxHeight += this._label._o.maxHeight;
}
this._setLimits(minWidth, minHeight, maxWidth, maxHeight);
}
});
return Button;
})
})();

4
lorgar/views/layout.js
View File

@ -76,8 +76,12 @@
}
}
if (this._w !== undefined && this._h !== undefined) {
child.setSize(this._w, this._h);
index = index || this._c.length - 1;
var c = this._c[index];
this._positionElement(c);
}
},
"clear": function() {

26
lorgar/views/view.js
View File

@ -191,9 +191,12 @@
}
if (needToTell) {
this.trigger("changeLimits", this);
if (this._w !== undefined && this._h !== undefined) {
this.setSize(this._w, this._h);
}
}
return needToTell && this._events.changeLimits && this._events.changeLimits.length; //to see if someone actually going to listen that event
return needToTell && this._events.changeLimits && this._events.changeLimits.length; //to see if someone actually going to listen that event, if not - return result
},
"setMaxSize": function(w, h) {
this._o.maxWidth = w;
@ -284,22 +287,27 @@
View.ViewType = {
Label: 0,
Image: 3,
View: 4,
Image: 4,
Button: 5,
View: 6,
Page: 102,
PanesList: 104
PanesList: 104,
Player: 107
};
View.ReversedViewType = {
"0": "Label",
"3": "Image",
"4": "View",
"4": "Image",
"5": "Button",
"6": "View",
"101": "Nav",
"102": "Page",
"104": "PanesList"
"104": "PanesList",
"107": "Player"
};
View.ViewTypesPaths = {
@ -307,7 +315,9 @@
Nav: "views/nav",
Page: "views/page",
PanesList: "views/panesList",
Image: "views/image"
Image: "views/image",
Button: "views/button",
Player: "views/player"
};
View.constructors = {

1
magnus/lib/wModel/CMakeLists.txt
View File

@ -13,5 +13,6 @@ add_jslib(wModel/themeStorage.js lib/wModel/themeStorage ${MAGNUS_DIR} node)
add_jslib(wModel/vocabulary.js lib/wModel/vocabulary ${MAGNUS_DIR} node)
add_jslib(wModel/attributes.js lib/wModel/attributes ${MAGNUS_DIR} node)
add_jslib(wModel/image.js lib/wModel/image ${MAGNUS_DIR} node)
add_jslib(wModel/button.js lib/wModel/button ${MAGNUS_DIR} node)
add_subdirectory(proxy)

11
magnus/pages/test.js
View File

@ -2,6 +2,7 @@
var Page = require("../lib/wModel/page");
var String = require("../lib/wModel/string");
var Button = require("../lib/wModel/button");
var Address = require("../lib/wType/address");
@ -13,6 +14,16 @@ var TestPage = Page.inherit({
var header = new String(this._address["+"](new Address(["message"])), "This is a test page");
header.addProperty("fontFamily", "casualFont");
this.addItem(header, 0, 0, 1, 1, Page.Aligment.CenterTop);
this._button = new Button(this._address["+"](new Address(["testButton"])));
this._button.setLabel("Push me");
this._button.on("activated", this._onActivate, this);
this.addItem(this._button, 1, 0, 1, 1, Page.Aligment.CenterTop);
},
"_onActivate": function() {
this.trigger("serviceMessage", "Button works!");
this._button.setEnabled(false);
setTimeout(this._button.setEnabled.bind(this._button, true), 3000);
}
});

2
perturabo/CMakeLists.txt
View File

@ -25,7 +25,7 @@ target_link_libraries(perturabo wSocket)
target_link_libraries(perturabo wDispatcher)
target_link_libraries(perturabo utils)
target_link_libraries(perturabo wModel)
target_link_libraries(perturabo wServerUtils)
target_link_libraries(perturabo wDatabase)
target_link_libraries(perturabo wServerUtils)
install(TARGETS perturabo RUNTIME DESTINATION bin)

12
perturabo/perturabo.cpp
View File

@ -86,11 +86,11 @@ void Perturabo::start()
server->listen(8082);
cout << "Registering models..." << endl;
attributes->registerModel(dispatcher, server);
commands->registerModel(dispatcher, server);
attributes->getRegistered(connector);
commands->getRegistered(connector);
for (; beg != end; ++beg) {
beg->second->registerModel(dispatcher, server);
beg->second->getRegistered(connector);
}
cout << "Opening and indexing databases..." << endl;
@ -115,11 +115,11 @@ void Perturabo::stop()
commands->enableCommand(W::String(u"clearDatabase"), false);
for (; beg != end; ++beg) {
beg->second->unregisterModel();
beg->second->getUnregistered();
}
commands->unregisterModel();
attributes->unregisterModel();
commands->getUnregistered();
attributes->getUnregistered();
server->stop();
}