bool qt_theme_settings::setThemeToWindow(std::shared_ptr<themes::theme> _theme)
{
if (_theme)
{
__INFO("themes", "theme_id is " << _theme->get_id() << ", is_image_loaded is " << _theme->is_image_loaded() << " tint_color " << _theme->get_tint_color().name());
if (_theme->is_image_loaded())
{
QPixmap pixmap = _theme->get_image();
QPainter pixPaint(&pixmap);
QBrush brush(_theme->get_tint_color());
pixPaint.fillRect(pixmap.rect(), brush);
Utils::InterConnector::instance().getMainWindow()->setBackgroundPixmap(pixmap, _theme->is_tile());
}
else
{
return false;
}
}
else
{
__INFO("themes", "setting empty theme");
QPixmap p;
Utils::InterConnector::instance().getMainWindow()->setBackgroundPixmap(p, true);
}
return true;
}
void qt_theme_settings::onThemeImageArrived(int _theme_id, bool _failed)
{
__INFO("themes", "_theme_id is " << _theme_id << ", failed is " << _failed);
if (!_failed)
{
auto theme = themeForId(_theme_id);
if (theme_request_.requested_id_ == _theme_id && theme_request_.callback_)
{
__INFO("themes", "_theme_id is " << _theme_id << ", calling callback");
theme_request_.callback_(theme);
theme_request_.reset();
}
}
}
void sstdata_open(sst_data_t* sstdata)
{
int ret;
int id;
int i;
int filterlen = 0;
struct _stat info;
_stat(sstdata->filename, &info);
if(info.st_size <12)
{
sstdata->key_num = 0;
__INFO("file content error:%s",sstdata->filename);
}
else
{
sstdata->file = fopen(sstdata->filename,"rb");
ret = fread(buffer_detach(sstdata->buf),12,1,sstdata->file);
sstdata->buf->NUL = 16;
id = buffer_getint(sstdata->buf);
sstdata->key_num = buffer_getint(sstdata->buf);
sstdata->max = buffer_getint(sstdata->buf);
if(sstdata->id != id)
{
__INFO("file content id:%d not equal read id:%d",sstdata->id,id);
}
if(info.st_size - 12 > sstdata->buf->buflen)
{
buffer_free(sstdata->buf);
sstdata->buf = buffer_new(info.st_size - 12);
}
buffer_clear(sstdata->buf);
buffer_seekfirst(sstdata->buf);
fseek(sstdata->file,12+filterlen,SEEK_SET);
ret = fread(buffer_detach(sstdata->buf),1,info.st_size - 12 - filterlen,sstdata->file);
i = sstdata->key_num;
sstdata->keys = (data_t*)xmalloc(sstdata->key_num * sizeof(data_t*));
for (i=0; i<sstdata->key_num; i++)
{
sstdata->keys[i] = buffer_getdata(sstdata->buf);
}
sstdata->bigest_key = sstdata->keys[sstdata->key_num-1];
sstdata->smallest_key = sstdata->keys[0];
}
}
void qt_theme_settings::themeSelected(int _theme_id, const QString& _targetContact)
{
auto theme = themeForId(_theme_id);
QString contactToOpen = _targetContact;
bool showSetThemeToCurrent = true;
if (contactToOpen == "")
{
contactToOpen = Logic::GetContactListModel()->contactToTryOnTheme();
showSetThemeToCurrent = false;
}
__INFO("themes", "theme id " << _theme_id << ", showSetThemeToCurrent is " << showSetThemeToCurrent << ", _targetContact is " << _targetContact << ", contactToOpen is " << contactToOpen)
Logic::GetContactListModel()->setCurrent(contactToOpen, true, [this, theme, _targetContact, showSetThemeToCurrent, contactToOpen](HistoryControlPage *page)
{
// consider peculiar case when themeSelected gets called without ThemePanelChoice-callback from previous call
if (setting_in_process_)
{
__INFO("themes", "setting " << theme->get_id() << " for " << contactToOpen << "(cto) while setting_in_process_ is true, ?!");
this->restoreThemesMapping();
}
setting_in_process_ = true;
page->update(_targetContact);
this->saveThemesMapping();
this->setThemeIdForContact(theme->get_id(), contactToOpen, false);
page->updateWidgetsTheme();
page->showThemesTopPanel(true, showSetThemeToCurrent, [this, theme, _targetContact, page, contactToOpen](ThemePanelChoice res) {
if (res == ThemePanelCancel || res == ThemePanelBackToSettings)
{
__INFO("themes", "showThemesTopPanel callback ThemePanelCancel|ThemePanelBackToSettings");
this->restoreThemesMapping();
this->setThemeIdForContact(this->themeIdForContact(contactToOpen), contactToOpen);
page->updateWidgetsTheme();
}
else if (res == ThemePanelSet)
{
__INFO("themes", "showThemesTopPanel callback ThemePanelSet");
this->setThemeIdForContact(theme->get_id(), contactToOpen);
}
else if (res == ThemePanelSetToAll)
{
__INFO("themes", "showThemesTopPanel callback ThemePanelSetToAll");
this->setDefaultTheme(theme);
}
setting_in_process_ = false;
});
});
}
void qt_theme_settings::setThemeIdForContact(int _theme_id, const QString& _aimId, const bool saveContactsThemes)
{
__INFO("themes", ": _theme_id is " << _theme_id << ", _aimId is " << _aimId);
auto theme = themeForId(_theme_id);
if (_aimId != "")
{
if (!setThemeToWindow(theme))
{
requestThemeImage(_theme_id, [this](themes::themePtr theme)
{
if (theme)
{
this->setThemeToWindow(theme);
}
});
}
contactsThemes_[_aimId] = _theme_id;
if (saveContactsThemes)
{
postContactsThemesToCore();
}
}
else if (theme)
{
setDefaultTheme(theme);
}
}
void qt_theme_settings::requestThemeImage(int _theme_id, std::function<void(themes::themePtr)> _callback)
{
__INFO("themes", "_theme_id is " << _theme_id);
Ui::GetDispatcher()->getTheme(_theme_id);
theme_request_.requested_id_ = _theme_id;
theme_request_.callback_ = _callback;
}
//write sstable head in file
void sstdata_writehead(sst_data_t* sstdata)
{
int ret;
buffer_clear(sstdata->buf);
buffer_putint(sstdata->buf,sstdata->id);
buffer_putint(sstdata->buf,sstdata->key_num);
buffer_putint(sstdata->buf,sstdata->max);
__INFO("buffer NUL:%d\n",sstdata->buf->NUL);
fseek(sstdata->file,0,SEEK_SET);
ret = fwrite(buffer_detach(sstdata->buf),1,sstdata->buf->NUL,sstdata->file);
fflush(sstdata->file);
__INFO("sstdata:flush data head flush : %s, NUL:%d, ret:%d ",sstdata->filename,sstdata->buf->NUL,ret);
buffer_clear(sstdata->buf);
}
void qt_theme_settings::saveThemesMapping()
{
__INFO("themes", "");
contactsThemesDump("before");
contactsThemesBackup_ = contactsThemes_;
if (default_theme_)
{
contactsThemesBackup_["default"] = default_theme_->get_id();
}
contactsThemesDump("after");
}
void sstdata_build(sst_data_t* sstdata)
{
__INFO("sstdata build : %s",sstdata->filename);
sstdata->file = fopen(sstdata->filename,"wb+");
if(!sstdata->file)
__PANIC("file open failed -- exiting:%s",sstdata->filename);
sstdata->key_num = 0;
sstdata->keys = (data_t*)xmalloc(sstdata->max * sizeof(data_t*));
}
void qt_theme_settings::restoreThemesMapping()
{
__INFO("themes", "");
contactsThemesDump("before");
int default_theme_id = contactsThemesBackup_["default"];
default_theme_ = themeForId(default_theme_id);
contactsThemesBackup_.remove("default");
contactsThemes_ = contactsThemesBackup_;
contactsThemesDump("after");
}
int sstdata_compactput( sst_data_t* sstdata,data_t* data )
{
int ret;
if(sstdata->max > sstdata->key_num)
{
buffer_clear(sstdata->buf);
buffer_putdata(sstdata->buf,data);
ret = fwrite(buffer_detach(sstdata->buf),sstdata->buf->NUL,1,sstdata->file);
sstdata->key_num++;
return 0;
}
else
{
__INFO("file is full");
return 1;
}
}
void qt_theme_settings::setDefaultTheme(std::shared_ptr<themes::theme> _theme)
{
default_theme_ = _theme;
__INFO("themes", "_theme id " << _theme->get_id() << " (tint_color " << _theme->get_tint_color().name() << ")");
if (!setThemeToWindow(default_theme_))
{
requestThemeImage(_theme->get_id(), [this](themes::themePtr theme)
{
if (theme)
{
this->setThemeToWindow(theme);
}
});
}
int theme_id = _theme->get_id();
contactsThemes_.clear();
postContactsThemesToCore();
postDefaultThemeIdToCore(theme_id);
}
int sstdata_put(sst_data_t* sstdata,data_t* data)
{
if(sstdata->max > sstdata->key_num)
{
// sstdata->keys[sstdata->key_num] = data;
_sstdata_binaryinsert(sstdata, data);
sstdata->key_num++;
sstdata->bigest_key = sstdata->keys[sstdata->key_num-1]; //will exist a bug
sstdata->smallest_key = sstdata->keys[0];
return 0;
}
else
{
__INFO("file is full");
return 1;
}
}
void qt_theme_settings::postContactsThemesToCore() const
{
Ui::gui_coll_helper cl_coll(GetDispatcher()->create_collection(), true);
core::ifptr<core::istream> data_stream(cl_coll->create_stream());
QString result = serializedContactsThemes();
uint size = result.toLatin1().size();
if (size)
{
data_stream->write((const uint8_t*) result.toLatin1().data(), size);
}
cl_coll.set_value_as_qstring("name", "contacts_themes");
cl_coll.set_value_as_stream("value", data_stream.get());
__INFO("themes", ", result string: " << result);
GetDispatcher()->post_message_to_core("themes/settings/set", cl_coll.get());
}
void qt_theme_settings::themes_data_unserialized()
{
if (default_theme_)
{
// replace temporary preloaded theme
auto theme = Ui::themes::loaded_themes()[default_theme_->get_id()];
if (theme)
{
default_theme_ = theme;
}
else
{
default_theme_ = initialTheme();
}
__INFO("themes", "default_theme_ id is " << default_theme_->get_id() << ", tint_color " << default_theme_->get_tint_color().name());
}
else
{
processNoDefaultThemeCase();
}
}
int main(int argc, char **argv)
{
(void) argc;
(void) argv;
_svr.bindaddr = HOST;
_svr.port = PORT;
_svr.db = silokatana_open();
_svr.el = aeCreateEventLoop(11024);
_svr.fd = anetTcpServer(_svr.neterr, _svr.port, _svr.bindaddr);
if (_svr.fd == ANET_ERR) {
__PANIC("openning port error #%d:%s", _svr.port, _svr.neterr);
exit(1);
}
if (anetNonBlock(_svr.neterr, _svr.fd) == ANET_ERR) {
__ERROR("set nonblock #%s",_svr.neterr);
exit(1);
}
aeCreateTimeEvent(_svr.el, 3000, server_cron, NULL, NULL);
if (aeCreateFileEvent(_svr.el, _svr.fd, AE_READABLE, accept_handler, NULL) == AE_ERR)
__ERROR("creating file event");
__INFO("siloserver starting, port:%d, pid:%d", PORT, (long)getpid());
printf("%s", _ascii_logo);
aeMain(_svr.el);
__ERROR("oops,exit");
aeDeleteEventLoop(_svr.el);
silokatana_close(_svr.db);
return 1;
}
void FileSharingWidget::resumeUploading()
{
assert(FsInfo_);
assert(FsInfo_->IsOutgoing());
assert(isState(State::PlainFile_Initial) || isState(State::ImageFile_Initial));
if (!getLocalFileMetainfo())
{
convertToUploadErrorView();
return;
}
if (isState(State::PlainFile_Initial))
{
setState(State::PlainFile_Uploading);
}
else
{
if (loadPreviewFromLocalFile())
{
setState(State::ImageFile_Uploading);
}
else
{
setState(State::PlainFile_Uploading);
}
}
startDataTransferAnimation();
__INFO(
"fs",
"resuming file sharing upload\n"
" local_path=<" << FsInfo_->GetLocalPath() << ">\n"
" uploading_id=<" << FsInfo_->GetUploadingProcessId() << ">");
}
void qt_theme_settings::contactsThemesDump(QString s) const
{
__INFO("themes", "(" << s << ") " << serializedContactsThemes());
}
void qt_theme_settings::unserialize(core::coll_helper _collection)
{
core::iarray* values_array = _collection.get_value_as_array("values");
if (!values_array)
{
assert(false);
return;
}
QString tint_color;
QByteArray imageDataArray;
QByteArray thumbDataArray;
QString contactsThemes;
int theme_id = -1;
bool tile = false;
for (int i = 0; i < values_array->size(); ++i)
{
const core::ivalue* val = values_array->get_at(i);
gui_coll_helper coll_val(val->get_as_collection(), false);
std::string name = coll_val.get_value_as_string("name");
core::istream* idata = coll_val.get_value_as_stream("value");
int len = idata->size();
const char* data = (char *)idata->read(len);
if (name == "id")
{
if (len == 4)
{
theme_id = *(data) | *(data+1) << 8 | *(data+2) << 16 | *(data+3) << 24;
}
}
else if (name == "image")
{
imageDataArray = QByteArray(data, len);
}
else if (name == "thumb")
{
thumbDataArray = QByteArray(data, len);
}
else if (name == "tint_color")
{
tint_color = QString(std::string(data, len).c_str());
}
else if (name == "contacts_themes")
{
contactsThemes = QString(std::string(data, len).c_str());
}
else if (name == "tile")
{
if (len == 1)
{
tile = *(data) & 0xFF;
}
}
}
if (theme_id != -1)
{
__INFO("themes", "unserialized default theme " << theme_id << "(tint_color " << tint_color << ")");
default_theme_ = std::make_shared<themes::theme>(theme_id, tint_color, imageDataArray, thumbDataArray, tile);
}
if (contactsThemes.length() > 1)
{
__INFO("themes", "contactsThemes " << contactsThemes);
QStringList list = contactsThemes.split(",");
for (int i = 0; i < list.count(); ++i)
{
QString item = list[i];
QStringList contactTheme = item.split(":");
if (contactTheme.count() == 2)
{
QString aimId = contactTheme[0];
int themeId = contactTheme[1].toInt();
if (themeId >= 0)
{
contactsThemes_[aimId] = themeId;
themesIdToLoad_.push_back(themeId);
}
}
}
}
}
