EjectOSD::EjectOSD() :
OSD(L"3RVX-EjectDispatcher"),
_mWnd(L"3RVX-EjectOSD", L"3RVX-EjectOSD") {
Skin *skin = SkinManager::Instance()->CurrentSkin();
if (skin->HasOSD("eject") == false) {
return;
}
/* TODO: NULL check*/
_mWnd.BackgroundImage(skin->ejectBackground);
if (skin->ejectMask != NULL) {
_mWnd.EnableGlass(skin->ejectMask);
}
_mWnd.Update();
Settings *settings = Settings::Instance();
_mWnd.AlwaysOnTop(settings->AlwaysOnTop());
_mWnd.HideAnimation(settings->HideAnim(), settings->HideSpeed());
_mWnd.VisibleDuration(settings->HideDelay());
UpdateWindowPositions(ActiveMonitors());
}
void NormalEnemy::setB2bodyPartPosition()
{
const Map<std::string, Bone*>& dic = armature->getBoneDic();
// CCArray *dickeyarr = dic->allKeys();
for(auto& element : dic)
{
//Ref *o = dickeyarr->objectAtIndex(i);
// CCString *key = dynamic_cast<CCString*>(o);
Skin *skin = (Skin*)element.second->getDisplayRenderNode();
string name = element.first;
if (skin != NULL) {
if (skin->isphysicsObject) {
if (1) {
b2Body *body = skin->body;
body->SetActive(true);
Point partpos = skin->getParentRelatePosition();
float partrotation = skin->getWorldRotation();
//printf("%f\n", partrotation);
body->SetTransform(b2Vec2(partpos.x/PTM_RATIO, partpos.y/PTM_RATIO), CC_DEGREES_TO_RADIANS(-partrotation));
}
}
}
}
}
bool SkinDialog::init(const char* skinPath, char* skinName) {
// if ( screenSnapshot == NULL )
// return false;
if ( drawImage == NULL )
return false;
memset(this->skinPath, 0, 512);
memset(this->skinShortPath, 0, 512);
strncpy(this->skinPath, skinPath, 511);
strncpy(this->skinShortPath, skinPath, 511);
this->skinName = skinName;
itemCount = open_directory(this->skinPath, this->skinShortPath, 0, 0, skinFilter, &skinItems);
if ( itemCount < 2)
return false;
itemTop = itemCurrent = 1;
// makeScreenSnapshot(screenSnapshot);
mainFont = FtFontManager::getInstance()->getMainFont();
fontSize = (Config::getInstance())->getIntegerValue("config/windows/font/size",12);
itemBottom = SKIN_DIALOG_ITEM_H / ( fontSize + 2 );
Skin* skin = Skin::getInstance();
alpha = skin->getAlphaValue("skin/config_dialog/dialog/alpha", PPA_SKINDLG_ALPHA);
bgColor = skin->getColorValue("skin/config_dialog/dialog/background_color", PPA_SKINDLG_BG_COLOR);
labelColor = skin->getColorValue("skin/config_dialog/dialog/label_color", PPA_SKINDLG_LABEL_COLOR);
title = i18nGetText(I18N_MSG_SKIN_TITLE);
sprintf(help, "%s %s %s %s", circleChar, i18nGetText(I18N_MSG_OK), crossChar, i18nGetText(I18N_MSG_CANCEL));
return true;
};
void Armature::draw(cocos2d::Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
if (_parentBone == nullptr && _batchNode == nullptr)
{
// CC_NODE_DRAW_SETUP();
}
for (auto& object : _children)
{
if (Bone *bone = dynamic_cast<Bone *>(object))
{
Node *node = bone->getDisplayRenderNode();
if (nullptr == node)
continue;
switch (bone->getDisplayRenderNodeType())
{
case CS_DISPLAY_SPRITE:
{
Skin *skin = static_cast<Skin *>(node);
skin->updateTransform();
BlendFunc func = bone->getBlendFunc();
if (func.src != _blendFunc.src || func.dst != _blendFunc.dst)
{
skin->setBlendFunc(bone->getBlendFunc());
}
else
{
skin->setBlendFunc(_blendFunc);
}
skin->draw(renderer, transform, flags);
}
break;
case CS_DISPLAY_ARMATURE:
{
node->draw(renderer, transform, flags);
}
break;
default:
{
node->visit(renderer, transform, flags);
// CC_NODE_DRAW_SETUP();
}
break;
}
}
else if(Node *node = dynamic_cast<Node *>(object))
{
node->visit(renderer, transform, flags);
// CC_NODE_DRAW_SETUP();
}
}
}
/** Computation of values only if MultiColumnList's geometry was dirty
*
* This function is used to speed up the drawing. It is automatically
* called from \ref soBetaGui::drawMultiColumnList when the geometryDirty
* flag of the MultiColumnList is true before the drawing. You know the
* Widget moved or was resized recently.
*
* This function is also responsible of the scissor rectangles computation.
* By example to avoid window to override the window scissor rectangle.
*
* \param mcl The MultiColumnList that moved or resized
*
*/
void RainbruRPG::OgreGui::wdMultiColumnList::
preDrawingComputation(MultiColumnList* mcl){
mMclAbsCorners = mcl->getAbsoluteCorners();
mMclDrawnCorners = mMclAbsCorners;
// Compute right scissor if parent
Window* parent = dynamic_cast<Window*>(mcl->getParent());
if (mcl->getParent()){
int pRight = parent->getRight();
pRight -= (parent->isVerticalScrollbarVisible()) ?
parent->getVerticalScrollbar()->getWidth() : 0;
if (pRight < mMclAbsCorners.right){
mMclAbsCorners.right = pRight;
}
else{
// Makes the line drawn
mMclDrawnCorners.right--;
}
}
// Compute bottom scissor if parent
if (mcl->getParent()){
int pBottom = parent->getBottom();
pBottom -= (parent->isHorizontalScrollbarVisible()) ?
parent->getHorizontalScrollbar()->getHeight() : 0;
if (pBottom < mMclAbsCorners.bottom){
mMclAbsCorners.bottom = pBottom;
}
else{
// Makes the line drawn
mMclDrawnCorners.bottom--;
}
}
// Handle parent scrollbar values
parentVerticalScrollbarValue = parent->getVerticalScrollbar()->getValue();
parentHorizontalScrollbarValue= parent->getHorizontalScrollbar()->getValue();
mMclHeaderBottomLine = mMclAbsCorners.top+mcl->getHeaderHeight();
mColumnCaption=Ogre::Rectangle(mMclAbsCorners);
mColumnCaption.bottom=mColumnCaption.top + mcl->getHeaderHeight();
maxMclRight = mMclAbsCorners.right;
// Compute parentUnderTitleY : We use the Skin::getTitleBarHeight()
// function as the title bar height depend on the skin
parentUnderTitleY = parent->getTop();
Skin* woeSkin = SkinManager::getSingleton().getSkin(parent);
parentUnderTitleY += woeSkin->getTitleBarHeight();
// Get the parent left value
parentLeftX = parent->getLeft();
}
Skin *Skin::createWithSpriteFrameName(const char *pszSpriteFrameName)
{
Skin *skin = new Skin();
if(skin && skin->initWithSpriteFrameName(pszSpriteFrameName))
{
skin->autorelease();
return skin;
}
CC_SAFE_DELETE(skin);
return NULL;
}
Skin *Skin::createWithSpriteFrameName(const std::string& pszSpriteFrameName)
{
Skin *skin = new Skin();
if(skin && skin->initWithSpriteFrameName(pszSpriteFrameName))
{
skin->autorelease();
return skin;
}
CC_SAFE_DELETE(skin);
return nullptr;
}
void SkinManager::parseScript(DataStreamPtr& stream, const String& groupName)
{
try
{
String line = "";
Skin *pSkin = 0;
while(!stream->eof())
{
line = stream->getLine();
// Ignore blanks & comments
if (!line.length() || line.substr(0, 2) == "//")
{
continue;
}
if (!pSkin)
{
// No current skin
// So first valid data should be skin name
#ifdef ROR_USE_OGRE_1_9
pSkin = (Skin *)createResource(line, groupName).getPointer();
#else
pSkin = (Skin *)create(line, groupName).getPointer();
#endif
if (pSkin)
{
pSkin->_notifyOrigin(stream->getName());
stream->skipLine("{");
}
} else
{
// Already in skin
if (line == "}")
{
// Finished
//addImpl((Ogre::ResourcePtr)pSkin);
pSkin = 0;
// NB skin isn't loaded until required
} else
{
ParseSkinAttribute(line, pSkin);
}
}
}
} catch(Ogre::ItemIdentityException e)
{
// this catches duplicates -> to be ignored
// this happens since we load the full skin data off the cache, so we don't need
// to re-add it to the SkinManager
return;
}
}
Skin *Skin::create(const std::string& pszFileName)
{
Skin *skin = new (std::nothrow) Skin();
if(skin && skin->initWithFile(pszFileName))
{
skin->autorelease();
return skin;
}
CC_SAFE_DELETE(skin);
return nullptr;
}
Skin *Skin::create()
{
Skin *skin = new (std::nothrow) Skin();
if(skin && skin->init())
{
skin->autorelease();
return skin;
}
CC_SAFE_DELETE(skin);
return nullptr;
}
Skin *Skin::create()
{
Skin *skin = new Skin();
if(skin && skin->init())
{
skin->autorelease();
return skin;
}
CC_SAFE_DELETE(skin);
return NULL;
}
void Armature::draw(cocos2d::Renderer *renderer, const kmMat4 &transform, bool transformUpdated)
{
if (_parentBone == nullptr && _batchNode == nullptr)
{
// CC_NODE_DRAW_SETUP();
}
for (auto& object : _children)
{
if (Bone *bone = dynamic_cast<Bone *>(object))
{
Node *node = bone->getDisplayRenderNode();
if (nullptr == node)
continue;
switch (bone->getDisplayRenderNodeType())
{
case CS_DISPLAY_SPRITE:
{
Skin *skin = static_cast<Skin *>(node);
skin->updateTransform();
bool blendDirty = bone->isBlendDirty();
if (blendDirty)
{
skin->setBlendFunc(bone->getBlendFunc());
}
skin->draw(renderer, transform, transformUpdated);
}
break;
case CS_DISPLAY_ARMATURE:
{
node->draw(renderer, transform, transformUpdated);
}
break;
default:
{
node->visit(renderer, transform, transformUpdated);
// CC_NODE_DRAW_SETUP();
}
break;
}
}
else if(Node *node = dynamic_cast<Node *>(object))
{
node->visit(renderer, transform, transformUpdated);
// CC_NODE_DRAW_SETUP();
}
}
}
void CS_DISPLAY_SPRITE_CREATE(Bone *bone, DecorativeDisplay *decoDisplay)
{
Skin *skin = NULL;
SpriteDisplayData *displayData = (SpriteDisplayData*)decoDisplay->getDisplayData();
//! remove .xxx
std::string textureName = displayData->displayName;
size_t startPos = textureName.find_last_of(".");
if(startPos != std::string::npos)
{
textureName = textureName.erase(startPos);
}
//! create display
if(textureName.compare("") == 0)
{
skin = Skin::create();
}
else
{
skin = Skin::createWithSpriteFrameName((textureName + ".png").c_str());
}
CCTextureAtlas *atlas = SpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->getTextureAtlas((textureName + ".png").c_str());
skin->setTextureAtlas(atlas);
TextureData *textureData = ArmatureDataManager::sharedArmatureDataManager()->getTextureData(textureName.c_str());
if(textureData)
{
//! Init display anchorPoint£¨ every Texture have a anchor point
skin->setAnchorPoint(ccp( textureData->pivotX, textureData->pivotY));
}
skin->setBone(bone);
skin->setSkinData(*bone->getBoneData());
decoDisplay->setDisplay(skin);
#if ENABLE_PHYSICS_DETECT
if (textureData && textureData->contourDataList.count() > 0)
{
//! create ContourSprite
ColliderDetector *colliderDetector = ColliderDetector::create(bone);
colliderDetector->addContourDataList(&textureData->contourDataList);
decoDisplay->setColliderDetector(colliderDetector);
}
#endif
}
void SkinManager::getMaterialAlternatives(Ogre::String materialName, std::vector<Skin *> &skinVector)
{
Ogre::ResourceManager::ResourceMapIterator it = getResourceIterator();
while (it.hasMoreElements())
{
Skin *skin = (Skin *)it.getNext().getPointer();
if (skin->hasReplacementForMaterial(materialName))
{
skinVector.push_back(skin);
}
}
}
void
skinUninstanceCB(Geometry *geo, InstanceDataHeader *header)
{
defaultUninstanceCB(geo, header);
Skin *skin = Skin::get(geo);
if(skin == nil)
return;
NativeSkin *natskin = (NativeSkin*)skin->platformData;
uint8 *data = skin->data;
float *invMats = skin->inverseMatrices;
skin->init(skin->numBones, natskin->numUsedBones, geo->numVertices);
memcpy(skin->inverseMatrices, invMats, skin->numBones*64);
rwFree(data);
for(int32 j = 0; j < skin->numUsedBones; j++)
skin->usedBones[j] = natskin->table1[j];
float *weights = skin->weights;
uint8 *indices = skin->indices;
uint8 *p = (uint8*)natskin->vertexBuffer;
int32 numVertices = header->numVertices;
float w[4];
uint8 i[4];
uint16 *ip;
while(numVertices--){
w[0] = w[1] = w[2] = w[3] = 0.0f;
i[0] = i[1] = i[2] = i[3] = 0;
for(int32 j = 0; j < skin->numWeights; j++)
w[j] = *p++/255.0f;
ip = (uint16*)p;
for(int32 j = 0; j < skin->numWeights; j++){
i[j] = natskin->table1[*ip++/3];
if(w[j] == 0.0f) i[j] = 0; // clean up a bit
}
p = (uint8*)ip;
for(int32 j = 0; j < 4; j++){
*weights++ = w[j];
*indices++ = i[j];
}
}
rwFree(natskin->vertexBuffer);
rwFree(natskin);
}
void DisplayFactory::createSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay)
{
Skin *skin = nullptr;
SpriteDisplayData *displayData = (SpriteDisplayData *)decoDisplay->getDisplayData();
std::string textureName = displayData->displayName;
size_t startPos = textureName.find_last_of(".");
if(startPos != std::string::npos)
{
textureName = textureName.erase(startPos);
}
//! create display
if(textureName.length() == 0)
{
skin = Skin::create();
}
else
{
skin = Skin::createWithSpriteFrameName((textureName + ".png").c_str());
}
decoDisplay->setDisplay(skin);
if (skin == nullptr)
{
return;
}
skin->setBone(bone);
initSpriteDisplay(bone, decoDisplay, displayData->displayName.c_str(), skin);
Armature *armature = bone->getArmature();
if (armature)
{
if (armature->getArmatureData()->dataVersion >= VERSION_COMBINED)
{
skin->setSkinData(displayData->skinData);
}
else
{
skin->setSkinData(*bone->getBoneData());
}
}
}
bool DestructableObject::init(cocos2d::Layer *gameScene_, b2World *gameWorld_, Point pos, string armatureName, float scale, float density)
{
gameScene = gameScene_;
gameWorld = gameWorld_;
density_ = density;
//load the armature
armature = Armature::create(armatureName);
armature->setPosition(pos);
armature->setScale(scale);
armature->setVisible(true);
armature->setAnchorPoint(Point(0.5,0.5));
gameScene->addChild(armature,12);
//create body
b2BodyDef bodyDef;
bodyDef.type = b2_dynamicBody;
bodyDef.position.Set(pos.x/PTM_RATIO,pos.y/PTM_RATIO);
body_ = gameWorld->CreateBody(&bodyDef);
b2PolygonShape dynamicBox;
dynamicBox.SetAsBox((0.5*armature->getScale()*armature->getContentSize().width/PTM_RATIO), 0.5*armature->getScale()*armature->getContentSize().height/PTM_RATIO);
b2FixtureDef fixtureDef;
fixtureDef.shape = &dynamicBox;
fixtureDef.density = density;
fixtureDef.friction = 0.3f;
fixtureDef.filter.categoryBits = ZOMBIE;
fixtureDef.filter.maskBits = BASE_GROUND | UPPER_GROUND | PLAYER;
fixtureDef.fixturetype = f_object;
body_->CreateFixture(&fixtureDef);
body_->SetUserData(&armature);
active = false;
// set the damaged part invisible
Vector<Node*> bonearr = armature->getChildren();
for(int i = 0; i< bonearr.size();i++)
{
Bone *bone = (Bone*)bonearr.at(i);
std::string boneName = bone->getName();
if (strstr(boneName.c_str(), "damaged")) {
Skin *skin = (Skin*)bone->getDisplayRenderNode();
if (skin !=NULL) {
skin->setVisible(false);
}
}
}
return true;
}
/*
** Retrieves the Rainmeter's meter windows in Z-order.
**
*/
BOOL CALLBACK MyEnumWindowsProc(HWND hwnd, LPARAM lParam)
{
bool logging = GetRainmeter().GetDebug() && DEBUG_VERBOSE;
const int classLen = _countof(METERWINDOW_CLASS_NAME) + (DEBUG_VERBOSE ? 32 : 1);
WCHAR className[classLen];
Skin* Window;
WCHAR flag;
if (GetClassName(hwnd, className, classLen) > 0 &&
wcscmp(className, METERWINDOW_CLASS_NAME) == 0 &&
(Window = GetRainmeter().GetSkin(hwnd)))
{
ZPOSITION zPos = Window->GetWindowZPosition();
if (zPos == ZPOSITION_ONDESKTOP ||
(zPos == ZPOSITION_NORMAL && GetRainmeter().IsNormalStayDesktop()) ||
zPos == ZPOSITION_ONBOTTOM)
{
if (lParam)
{
((std::vector<Skin*>*)lParam)->push_back(Window);
}
if (logging) flag = L'+';
}
else
{
if (logging) flag = L'-';
}
if (logging)
{
LogDebugF(L"%c [%c] 0x%p : %s (Name: \"%s\", zPos=%i)",
flag, IsWindowVisible(hwnd) ? L'V' : L'H', hwnd, className, Window->GetFolderPath().c_str(), (int)zPos);
}
}
else
{
if (logging)
{
flag = (hwnd == System::GetHelperWindow()) ? L'o' : ' ';
LogDebugF(L"%c [%c] 0x%p : %s", flag, IsWindowVisible(hwnd) ? L'V' : L'H', hwnd, className);
}
}
return TRUE;
}
std::wstring GetSectionSourceString(Section* section)
{
std::wstring source;
if (section)
{
Skin* skin = section->GetSkin();
if (skin)
{
source = skin->GetSkinPath();
source += L" - ";
}
source += L'[';
source += section->GetOriginalName();
source += L']';
}
return source;
}
int main(int argc, char** argv)
{
QGuiApplication app(argc, argv);
app.setApplicationName("sasquatch");
app.setOrganizationName("MediaTrolls");
app.setOrganizationDomain("sasquatch.com");
GlobalSettings *settings = new GlobalSettings(&app);
if (app.arguments().contains("--help") || app.arguments().contains("-help") || app.arguments().contains("-h")) {
printf("Usage: sasquatch [-option value] [-option=value]\n"
"\n"
"Options (default):\n");
for (int i = 0; i < GlobalSettings::OptionLength; ++i) {
printf(" -%-20s %s \t (%s)\n",
qPrintable(settings->name((GlobalSettings::Option)i)),
qPrintable(settings->doc((GlobalSettings::Option)i)),
qPrintable(settings->value((GlobalSettings::Option)i).toString()));
}
printf("\n");
// try to print skin specific settings
settings->parseArguments(app.arguments());
SkinManager *skinManager = new SkinManager(settings);
if (skinManager->skins().contains(settings->value(GlobalSettings::Skin).toString())) {
Skin *skin = skinManager->skins().value(settings->value(GlobalSettings::Skin).toString());
if (!skin->parseManifest())
return 1;
printf("\n"
"Skin '%s' Options (default):\n", qPrintable(skin->name()));
Settings *skinSettings = skin->settings();
foreach (const QString &key, skinSettings->keys()) {
printf(" -%-20s %s \t (%s)\n",
qPrintable(key),
qPrintable(skinSettings->doc(key)),
qPrintable(skinSettings->value(key).toString()));
}
}
Skin * Skin::switchskin(char *newskintitle) {
Skin *newskin = new Skin();
if (!newskin->load(newskintitle,true)) {
//delete newskin;
sprintf(szStatmsg, "Error loading '%s' skin (files missing?)",newskintitle);
statusmsg = szStatmsg;
status_change = 1;
return newskin;
}
doredraw++;
need_refresh++;
CurrentSkin = newskin;
make_toolbar();
// delete this;
sprintf(szStatmsg, "%s skin loaded",newskintitle);
statusmsg = szStatmsg;
status_change = 1;
return this;
}
/*
** Returns the first window whose position is not ZPOSITION_ONDESKTOP,
** ZPOSITION_BOTTOM, or ZPOSITION_NORMAL.
**
*/
HWND System::GetBackmostTopWindow()
{
HWND winPos = c_HelperWindow;
// Skip all ZPOSITION_ONDESKTOP, ZPOSITION_BOTTOM, and ZPOSITION_NORMAL windows
while (winPos = ::GetNextWindow(winPos, GW_HWNDPREV))
{
Skin* wnd = GetRainmeter().GetSkin(winPos);
if (!wnd ||
(wnd->GetWindowZPosition() != ZPOSITION_NORMAL &&
wnd->GetWindowZPosition() != ZPOSITION_ONDESKTOP &&
wnd->GetWindowZPosition() != ZPOSITION_ONBOTTOM))
{
break;
}
}
return winPos;
}
void HttpClientPrivate::readQmlRequest(const QString& get)
{
QStringList requestTokens = get.split('/', QString::SkipEmptyParts);
if(requestTokens.length() != 3) {
printRequestFormatErrorMessage(get);
return;
}
QString skinName = requestTokens.at(1);
QString fileName = requestTokens.at(2);
Skin* skin = (m_skinManager->skins().value(skinName, 0));
if(skin == 0) {
qWarning() << "HttpClient: requested skin: " << skinName << " .. but this skin is unknown";
return;
}
sendFile( skin->path() + "/remoteqml/" + fileName);
}
void GLRenderData::render(Shader* shader, Renderer* renderer)
{
GLShader* glshader = static_cast<GLShader*>(shader);
int programId = glshader->getProgramId();
int indexCount = mesh_->getIndexCount();
int vertexCount = mesh_->getVertexCount();
int mode = draw_mode();
#ifdef DEBUG_SHADER
LOGV("SHADER: RenderData::render binding vertex arrays to program %d %p %d vertices, %d indices",
programId, this, vertexCount, indexCount);
#endif
if (shader->hasBones())
{
Skin* skin = (Skin*) owner_object()->getComponent(Skin::getComponentType());
if (skin)
{
skin->bindBuffer(renderer, shader);
}
}
mesh_->getVertexBuffer()->bindToShader(shader, mesh_->getIndexBuffer());
checkGLError("renderMesh::mesh_->getVertexBuffer()->bindToShader(");
switch (mesh_->getIndexSize())
{
case 2:
glDrawElements(mode, indexCount, GL_UNSIGNED_SHORT, 0);
break;
case 4:
glDrawElements(mode, indexCount, GL_UNSIGNED_INT, 0);
break;
default:
glDrawArrays(mode, 0, vertexCount);
break;
}
checkGLError(" RenderData::render after draw");
glBindVertexArray(0);
}
TextFragment::TextFragment(PostRef post_ref,
const std::string& text,
bool is_link,
const std::string& link,
Skin::font_type type,
const Color& color,
bool small,
bool bold,
bool italic,
bool underline,
const Color& underline_color,
bool strike,
const Color& strike_color,
bool is_spoiler) :
PostWidget(post_ref),
m_text(text),
m_is_link(is_link),
m_link(link),
m_font_type(type),
m_glyph_arrays_dirty(true),
m_color(color),
m_small(small),
m_bold(bold),
m_italic(italic),
m_underline(underline),
m_underline_color(underline_color),
m_strike(strike),
m_strike_color(strike_color),
m_is_spoiler(is_spoiler),
m_spoiled(true)
{
g_skin.includeChars(m_text);
if(m_is_link)
{
m_underline = true;
m_color = g_skin.getColor(Skin::color_type::UNSPECIFIC_LINK);
m_underline_color = m_color;
}
}
void
Skin::draw_debug()
{
if (!_show_memes)
return;
//if (!debug)
// return;
// frozen: blue
// sticky: orange
// unglued: grey
Skin* cur = upcast(cur_subdiv_bbase());
if (!cur) return;
Bvert_list verts = cur->skin_verts();
Bvert_list frozen = cur->frozen_verts(verts);
verts = verts.minus(frozen);
Bvert_list sticky = cur->sticky_verts(verts);
Bvert_list unglued = verts.minus(sticky);
GL_VIEW::draw_pts(frozen.pts(), Color::blue, 0.8, 8);
GL_VIEW::draw_pts(sticky.pts(), Color::orange, 0.8, 8);
GL_VIEW::draw_pts(unglued.pts(), Color::grey6, 0.8, 8);
if (debug) GL_VIEW::draw_lines(
bundle_lines(verts.pts(), cur->track_points(verts)),
Color::yellow,
0.8,
1,
false
);
if (debug) GL_VIEW::draw_lines(
bundle_lines(verts.pts(), centroids(verts)),
Color::red,
0.8,
1,
false
);
}
bool Editor_controller::Load(Skin& skin) {
controller_layout.Set_filename("interfaces/editor.yaml");
controller_layout.Set_skin(&skin);
if(controller_layout.Load_yaml())
{
Namelist protlist = skin.Get_prototype_list();
Menu* create_menu = dynamic_cast<Menu*>(controller_layout.Get_widget("create menu"));
std::cout<<"THE CREATE MENU: "<<create_menu<<std::endl;
for(Namelist::iterator i = protlist.begin(); i != protlist.end(); ++i)
{
create_menu->Add_option(*i);
}
events[Event(controller_layout.Get_widget("create button"), "clicked")] = "create";
//Widget attribute editing interfaces
Widget_attribute_controller* widget_controller = new Widget_attribute_controller;
widget_controller->Load(layout_controller->Get_skin());
widget_controller->Set_layout_controller(*layout_controller);
attribute_controllers["widget"] = widget_controller;
Button_attribute_controller* button_controller = new Button_attribute_controller;
button_controller->Load(layout_controller->Get_skin());
button_controller->Set_layout_controller(*layout_controller);
attribute_controllers["button"] = button_controller;
Label_attribute_controller* label_controller = new Label_attribute_controller;
label_controller->Load(layout_controller->Get_skin());
label_controller->Set_layout_controller(*layout_controller);
attribute_controllers["label"] = label_controller;
Menu_attribute_controller* menu_controller = new Menu_attribute_controller;
menu_controller->Load(layout_controller->Get_skin());
menu_controller->Set_layout_controller(*layout_controller);
attribute_controllers["menu"] = menu_controller;
dynamic_cast<Container*>(controller_layout.Get_widget("layout expander"))->Add_child(layout_controller->Get_root_tree());
events[Event(controller_layout.Get_widget("save"), "clicked")] = "save";
events[Event(controller_layout.Get_widget("load"), "clicked")] = "load";
events[Event(controller_layout.Get_widget("remove"), "clicked")] = "remove";
events[Event(controller_layout.Get_widget("cut"), "clicked")] = "cut";
events[Event(controller_layout.Get_widget("paste"), "clicked")] = "paste";
events[Event(controller_layout.Get_widget("move up"), "clicked")] = "move up";
events[Event(controller_layout.Get_widget("move down"), "clicked")] = "move down";
controller_layout.Get_widget("vertical box")->Set_event_queue(&gui_events);
return true;
}
return false;
}
void Tab::updateShape(const ivec2& window_size)
{
int border_size = getBorderSize();
int scrollbar_width = g_lamp_settings.getScrollbarWidth();
m_window_size = window_size;
Rectf scrollbar_rect((float)m_window_size.x - scrollbar_width, 0, (float)m_window_size.x, (float)m_window_size.y);
m_scrollbar->AsScrollbar()->setShape(scrollbar_rect);
Rectf post_rect(0, 0, (float)m_window_size.x, (float)m_window_size.y);
post_rect.x1 += border_size;
post_rect.y1 += border_size;
post_rect.x2 -= std::max(border_size, scrollbar_width);
for(std::list<PostRef>::iterator it = m_threads.begin();
it != m_threads.end();
it++)
{
float thread_height = 0;
(*it)->updateShape(post_rect, thread_height);
post_rect.offset(vec2(0, thread_height + border_size));
}
gl::Texture2dRef crest_image = g_skin.getImage(image_type::SHACK_CREST);
if(crest_image)
{
m_crest_rect.y1 = post_rect.y1;
float tab_width = m_window_size.x - (float)scrollbar_width;
float mid_width = tab_width / 2.0f;
float image_width = (float)crest_image->getWidth();
float image_height = (float)crest_image->getHeight();
if(image_width > tab_width)
{
float scale = tab_width / image_width;
image_width *= scale;
image_height *= scale;
}
m_crest_rect.x1 = mid_width - (image_width / 2.0f);
m_crest_rect.x2 = m_crest_rect.x1 + image_width;
m_crest_rect.y2 = m_crest_rect.y1 + image_height;
}
updateScrollbar();
}
void TextFragment::calcWordWidthInfo(const std::string& word)
{
// we add an H to the end, so that we can
// calculate the width of the last character
// with full-blocking kerning
std::string temp_word = word + 'H';
gl::TextureFont::DrawOptions draw_options;
draw_options.ligate(false);
std::vector<std::pair<uint16_t, vec2>> glyph_array = getTextureFont()->getGlyphPlacements(temp_word, draw_options);
std::vector<std::pair<uint16_t, vec2>>::iterator it = glyph_array.begin();
if(it != glyph_array.end())
{
std::pair<uint16_t, float> glyph_width;
float word_width = 0;
float last_width = 0;
size_t glyph_count = 0;
glyph_width.first = it->first;
it++;
for(; it != glyph_array.end(); it++)
{
if(it->second.x == 0 &&
it->second.y != 0)
{
// un-wrap this newline
it->second.x = last_width + (g_skin.getCellSize() / 5.0f);
it->second.y = 0;
}
glyph_width.second = it->second.x - last_width;
last_width = it->second.x;
word_width += glyph_width.second;
glyph_count++;
m_glyph_widths_array.push_back(glyph_width);
glyph_width.first = it->first;
}
WordInfo glyph_word;
glyph_word.m_glyph_count = glyph_count;
glyph_word.m_width = word_width;
glyph_word.m_newline = word.back() == '\n' ? true : false;
m_glyph_words_array.push_back(glyph_word);
}
}
bool TextFragment::getInteractive(const vec2& pos) const
{
if(m_is_link || m_is_spoiler)
{
vec2 location = pos + vec2(0, g_skin.getFontBaslineOffset(m_font_type, m_small, m_bold, m_italic));
for(size_t i = 0; i < m_rect_array.size(); i++)
{
if(m_rect_array[i].getWidth() > 0)
{
if(m_rect_array[i].contains(location))
{
return true;
}
}
}
}
return false;
}
