bool Platform::satisfy_platform(Platform* os)
{
bool ret = (!strlen(os->getName()))? true : (compareString(getName(), os->getName()));
ret &= (!strlen(os->getDistribution()))? true : (compareString(strDistrib.c_str(), os->getDistribution()));
ret &= (!strlen(os->getRelease()))? true : (compareString(strRelease.c_str(), os->getRelease()));
return ret;
}
bool Texture::load(FS::IFile& file)
{
PROFILE_FUNCTION();
const char* path = getPath().c_str();
size_t len = getPath().length();
bool loaded = false;
if (len > 3 && compareString(path + len - 4, ".dds") == 0)
{
loaded = loadDDS(file);
}
else if (len > 3 && compareString(path + len - 4, ".raw") == 0)
{
loaded = loadRaw(file);
}
else
{
loaded = loadTGA(file);
}
if (!loaded)
{
g_log_warning.log("Renderer") << "Error loading texture " << path;
return false;
}
m_size = file.size();
return true;
}
void recursive(string temp, vector<char> &nums1, vector<char> &nums2, string &low, string &high, int &total) {
int len = temp.length();
if (len > low.length() && len < high.length()) {
if (len > 1 && temp[0] != '0') total++;
}
else if (len == low.length() && len < high.length()) {
if (compareString(low, temp)) {
if (len > 1 && temp[0] == '0');
else total++;
}
}
else if (len == high.length() && len > low.length()) {
if (compareString(temp, high)) {
if (len > 1 && temp[0] == '0');
else total++;
}
}
else if (len > high.length()) {
return;
}
else if (len == low.length() && len == high.length()) {
if (compareString(temp, high) && compareString(low, temp)) {
if (len > 1 && temp[0] == '0');
else total++;
}
}
for (int i = 0; i < nums1.size(); ++i) {
recursive(nums1[i] + temp + nums2[i], nums1, nums2, low, high, total);
}
}
void LuaScript::parseProperties()
{
static const char* PROPERTY_MARK = "-- LUMIX PROPERTY";
const int PROPERTY_MARK_LENGTH = stringLength(PROPERTY_MARK);
const char* str = m_source_code.c_str();
const char* prop = findSubstring(str, PROPERTY_MARK);
while (prop)
{
const char* token = prop + PROPERTY_MARK_LENGTH + 1;
Property& property = m_properties.pushEmpty();
token = getToken(token, property.name, sizeof(property.name));
char type[50];
token = getToken(token, type, sizeof(type));
if (compareString(type, "entity") == 0)
{
property.type = Property::ENTITY;
}
else if (compareString(type, "float") == 0)
{
property.type = Property::FLOAT;
}
else
{
property.type = Property::ANY;
}
prop = findSubstring(prop + 1, PROPERTY_MARK);
}
}
void Texture::save()
{
char ext[5];
ext[0] = 0;
PathUtils::getExtension(ext, 5, getPath().c_str());
if (compareString(ext, "raw") == 0 && m_BPP == 2)
{
FS::FileSystem& fs = m_resource_manager.getFileSystem();
FS::IFile* file = fs.open(fs.getDefaultDevice(),
getPath(),
FS::Mode::CREATE_AND_WRITE);
file->write(&m_data[0], m_data.size() * sizeof(m_data[0]));
fs.close(*file);
}
else if (compareString(ext, "tga") == 0 && m_BPP == 4)
{
saveTGA();
}
else
{
g_log_error.log("Renderer") << "Texture " << getPath().c_str()
<< " can not be saved - unsupported format";
}
}
void Material::deserializeUniforms(JsonSerializer& serializer)
{
serializer.deserializeArrayBegin();
clearUniforms();
while (!serializer.isArrayEnd())
{
Uniform& uniform = m_uniforms.pushEmpty();
serializer.nextArrayItem();
serializer.deserializeObjectBegin();
char label[256];
auto uniform_type = bgfx::UniformType::End;
while (!serializer.isObjectEnd())
{
serializer.deserializeLabel(label, 255);
if (compareString(label, "name") == 0)
{
serializer.deserialize(uniform.m_name, Uniform::MAX_NAME_LENGTH, "");
uniform.m_name_hash = crc32(uniform.m_name);
}
else if (compareString(label, "int_value") == 0)
{
uniform_type = bgfx::UniformType::Int1;
uniform.m_type = Uniform::INT;
serializer.deserialize(uniform.m_int, 0);
}
else if (compareString(label, "float_value") == 0)
{
uniform.m_type = Uniform::FLOAT;
serializer.deserialize(uniform.m_float, 0);
}
else if (compareString(label, "matrix_value") == 0)
{
uniform_type = bgfx::UniformType::Mat4;
uniform.m_type = Uniform::MATRIX;
serializer.deserializeArrayBegin();
for (int i = 0; i < 16; ++i)
{
serializer.deserializeArrayItem(uniform.m_matrix[i], 0);
ASSERT(i == 15 || !serializer.isArrayEnd());
}
serializer.deserializeArrayEnd();
}
else if (compareString(label, "time") == 0)
{
uniform.m_type = Uniform::TIME;
serializer.deserialize(uniform.m_float, 0);
}
else
{
g_log_warning.log("material") << "Unknown label \"" << label << "\"";
}
}
uniform.m_handle = bgfx::createUniform(uniform.m_name, uniform_type);
serializer.deserializeObjectEnd();
}
serializer.deserializeArrayEnd();
}
void InternalPortModel::updateInputPortColor(void)
{
if((type == INPUTD) && input && (string(input->getName()) != "*"))
{
strColor = COLOR_NOMAL;
if(!destinationArrows.size())
strColor = (input->isRequired()) ? COLOR_WARNING : COLOR_NOMAL;
else
{
std::vector<ArrowModel*>::iterator itr;
for(itr=destinationArrows.begin(); itr<destinationArrows.end(); itr++)
if((*itr)->getSource() &&
Glib::RefPtr<InternalPortModel>::cast_dynamic((*itr)->getSource()))
{
OutputData* outp = Glib::RefPtr<InternalPortModel>::cast_dynamic((*itr)->getSource())->getOutput();
if(outp && !compareString(outp->getName(), input->getName()))
{
strColor = COLOR_MISMATCH;
break;
}
}
}
poly->property_fill_color().set_value(strColor.c_str());
}
}
// -----------------------------------------------------------------------------
// Implements checking if a given MIME type is supported or not
// -----------------------------------------------------------------------------
//
TBool CAknsWallpaperPlugin::IsMimeTypeSupportedL(const TDesC& aMimeTypeString)
{
// Check for a type separator in the string
TInt pos = aMimeTypeString.Find(KAknsWallpaperPluginSeparator);
// Leave if no separator was found.. the MIME
// standard requires it
if (pos == KErrNotFound)
{
User::Leave(KErrArgument);
}
// Copy the full Mime type string (needed for uppercase)
HBufC* fullBuf = aMimeTypeString.AllocLC();
TPtr fullString = fullBuf->Des();
fullString.UpperCase();
// Construct the compare string
TPtrC compareString(aMimeTypeString.Left(pos));
// Perform the comparison
TBool ret = EFalse;
// Mime type case: IMAGE/* except IMAGE/X-OTA-BITMAP
if (compareString.CompareF(KAknsWallpaperPluginMimeTypeImage) == 0 &&
!(fullString.CompareF(KAknsWallpaperPluginMimeTypeOTABitmap) == 0))
{
ret = ETrue;
}
CleanupStack::PopAndDestroy(fullBuf);
return ret;
}
SDB_API int sdb_match (const char *str, const char *glob) {
int flags = SDB_LIKE_NONE;
int glob_len;
int begin = 0;
if (!str || !glob)
return 0;
glob_len = strlen (glob);
if (haveSuffix (glob, glob_len, "?i")) {
glob_len -= 2;
flags |= SDB_LIKE_ICASE;
}
if (havePrefix (glob, glob_len, "%")) {
glob++;
glob_len--;
flags |= SDB_LIKE_BASE64;
}
if (havePrefix (glob, glob_len, "^")) {
glob++;
glob_len--;
flags |= SDB_LIKE_START;
}
if (haveSuffix (glob+begin, glob_len-begin, "$")) {
glob_len--;
flags |= SDB_LIKE_END;
}
return compareString (str, glob, glob_len, flags);
}
static void alpha_blending(lua_State* L, const char* mode)
{
Shader* shader = getShader(L);
if (!shader) return;
if (compareString(mode, "add") == 0)
{
shader->m_render_states |= BGFX_STATE_BLEND_ADD;
}
else if (compareString(mode, "alpha") == 0)
{
shader->m_render_states |= BGFX_STATE_BLEND_ALPHA;
}
else
{
g_log_error.log("Renderer") << "Uknown blend mode " << mode << " in " << shader->getPath().c_str();
}
}
bool Model::parseVertexDef(FS::IFile& file, bgfx::VertexDecl* vertex_definition)
{
vertex_definition->begin();
uint32 attribute_count;
file.read(&attribute_count, sizeof(attribute_count));
for (uint32 i = 0; i < attribute_count; ++i)
{
char tmp[50];
uint32 len;
file.read(&len, sizeof(len));
if (len > sizeof(tmp) - 1)
{
return false;
}
file.read(tmp, len);
tmp[len] = '\0';
if (compareString(tmp, "in_position") == 0)
{
vertex_definition->add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float);
}
else if (compareString(tmp, "in_colors") == 0)
{
vertex_definition->add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true, false);
}
else if (compareString(tmp, "in_tex_coords") == 0)
{
vertex_definition->add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float);
}
else if (compareString(tmp, "in_normal") == 0)
{
vertex_definition->add(bgfx::Attrib::Normal, 4, bgfx::AttribType::Uint8, true, true);
}
else if (compareString(tmp, "in_tangents") == 0)
{
vertex_definition->add(bgfx::Attrib::Tangent, 4, bgfx::AttribType::Uint8, true, true);
}
else if (compareString(tmp, "in_weights") == 0)
{
vertex_definition->add(bgfx::Attrib::Weight, 4, bgfx::AttribType::Float);
}
else if (compareString(tmp, "in_indices") == 0)
{
vertex_definition->add(bgfx::Attrib::Indices, 4, bgfx::AttribType::Int16, false, true);
}
else
{
ASSERT(false);
return false;
}
uint32 type;
file.read(&type, sizeof(type));
}
vertex_definition->end();
return true;
}
IFileDevice* getDevice(const char* device)
{
for (int i = 0; i < m_devices.size(); ++i)
{
if (compareString(m_devices[i]->name(), device) == 0) return m_devices[i];
}
return nullptr;
}
IPlugin* getPlugin(const char* name) override
{
for (int i = 0; i < m_plugins.size(); ++i)
{
if (compareString(m_plugins[i]->getName(), name) == 0)
{
return m_plugins[i];
}
}
return 0;
}
RSTATE Executable::state(void)
{
if(!broker->initialized())
initialize();
// Updating real module state on demand
// Notice that this is a blocking method
execMachine->refresh();
const char* strState = execMachine->currentState()->getName();
if(compareString(strState, "SUSPENDED"))
return SUSPENDED;
if(compareString(strState, "READY"))
return READY;
if(compareString(strState, "CONNECTING"))
return CONNECTING;
if(compareString(strState, "RUNNING"))
return RUNNING;
if(compareString(strState, "DEAD"))
return DEAD;
if(compareString(strState, "DYING"))
return DYING;
std::cerr<<"Unknown state!"<<endl;
return STUNKNOWN;
}
IPlugin* StaticPluginRegister::create(const char* name, Engine& engine)
{
auto* i = s_first_plugin;
while (i)
{
if (compareString(name, i->name) == 0)
{
return i->creator(engine);
}
i = i->next;
}
return nullptr;
}
int insertHashTable(HashTable* hashtable,char* key,int value){
unsigned int index = hashCode(key)%HASHSIZE;
hashNode* newNode = (hashNode*)malloc(sizeof(hashNode));
newNode->key = (char*)malloc(sizeof(char) * (strlen(key)+1));
memcpy(newNode->key,key,strlen(key)+1);
newNode->key[strlen(key)]='\0';
newNode->value = value;
hashNode* n=searchHashTable(hashtable, key);
if (n){
n->value = value;
return 0;
}
else{
newNode->next = hashtable->content[index];
hashtable->content[index] = newNode;
hashtable->size=hashtable->size+1;
nodeIndex* insertIndex=(nodeIndex*)malloc(sizeof(nodeIndex));
insertIndex->whichNode=newNode;
insertIndex->next=NULL;
nodeIndex* p=hashtable->indexHead;
if(!p) hashtable->indexHead=insertIndex;
else if(compareString(p->whichNode->key, key)==1){
hashtable->indexHead=insertIndex;
insertIndex->next=p;
}
else{
while (p) {
if(!p->next||(compareString(p->whichNode->key, key)==-1&&compareString(p->next->whichNode->key, key)==1)){
nodeIndex* mid = p->next;
p->next=insertIndex;
insertIndex->next=mid;
break;
}
p=p->next;
}
}
return 1;
}
}
int getPassIdx(const char* pass) override
{
for (int i = 0; i < m_passes.size(); ++i)
{
if (compareString(m_passes[i], pass) == 0)
{
return i;
}
}
auto& new_pass = m_passes.pushEmpty();
copyString(new_pass, pass);
return m_passes.size() - 1;
}
int getShaderDefineIdx(const char* define) override
{
for (int i = 0; i < m_shader_defines.size(); ++i)
{
if (compareString(m_shader_defines[i], define) == 0)
{
return i;
}
}
auto& new_define = m_shader_defines.pushEmpty();
copyString(new_define, define);
return m_shader_defines.size() - 1;
}
int main()
{
char str1[15];
char str2[15];
printf("Enter first string!");
scanf("%s", &str1);
printf("Enter second string");
scanf("%s", &str2);
compareString(str1, str2);
findEmbeddedString(str1, str2);
return(0);
}
bool mount(IFileDevice* device) override
{
for (int i = 0; i < m_devices.size(); i++)
{
if (m_devices[i] == device)
{
return false;
}
}
if (compareString(device->name(), "memory") == 0)
{
m_memory_device.m_devices[0] = device;
m_memory_device.m_devices[1] = nullptr;
}
else if (compareString(device->name(), "disk") == 0)
{
m_disk_device.m_devices[0] = device;
m_disk_device.m_devices[1] = nullptr;
}
m_devices.push(device);
return true;
}
Texture* Material::getTextureByUniform(const char* uniform) const
{
if (!m_shader)
{
return nullptr;
}
for (int i = 0, c = m_shader->getTextureSlotCount(); i < c; ++i)
{
if (compareString(m_shader->getTextureSlot(i).m_uniform, uniform) == 0)
{
return m_textures[i];
}
}
return nullptr;
}
void InternalPortModel::updateOutputPortColor(void)
{
if(type == OUTPUTD)
{
strColor = COLOR_NOMAL;
std::vector<ArrowModel*>::iterator itr;
for(itr=sourceArrows.begin(); itr<sourceArrows.end(); itr++)
if((*itr)->getDestination() &&
Glib::RefPtr<InternalPortModel>::cast_dynamic((*itr)->getDestination()))
{
InputData* inp = Glib::RefPtr<InternalPortModel>::cast_dynamic((*itr)->getDestination())->getInput();
if(inp && (string(inp->getName()) != "*") &&
!compareString(output->getName(), inp->getName()))
{
strColor = COLOR_MISMATCH;
break;
}
}
poly->property_fill_color().set_value(strColor.c_str());
}
}
int main()
{
myString *fat, *son;
char in;
int result = 0;
initString( &fat );
initString( &son );
printf("请输入父串(以#号结束)：");
scanf("%c", &in);
while( '#'!=in && fat->lenght < MAXSIZE)
{
fat->data[fat->lenght++] = in;
scanf("%c", &in);
}
printf("请输入子串(以#号结束)：");
scanf("%c", &in);
scanf("%c", &in);
while( '#'!=in && son->lenght < MAXSIZE )
{
son->data[son->lenght++] = in;
scanf("%c", &in);
}
result = compareString( *fat, *son );
if( result )
printf("父串包含子串。");
else
printf("不包含。");
return 0;
}
static void uniform(lua_State* L, const char* name, const char* type)
{
auto* shader = getShader(L);
if (!shader) return;
auto& u = shader->m_uniforms.emplace();
copyString(u.name, name);
u.name_hash = crc32(name);
if (compareString(type, "float") == 0)
{
u.type = Shader::Uniform::FLOAT;
u.handle = bgfx::createUniform(name, bgfx::UniformType::Vec4);
}
else if (compareString(type, "color") == 0)
{
u.type = Shader::Uniform::COLOR;
u.handle = bgfx::createUniform(name, bgfx::UniformType::Vec4);
}
else if (compareString(type, "int") == 0)
{
u.type = Shader::Uniform::INT;
u.handle = bgfx::createUniform(name, bgfx::UniformType::Int1);
}
else if (compareString(type, "matrix4") == 0)
{
u.type = Shader::Uniform::MATRIX4;
u.handle = bgfx::createUniform(name, bgfx::UniformType::Mat4);
}
else if (compareString(type, "time") == 0)
{
u.type = Shader::Uniform::TIME;
u.handle = bgfx::createUniform(name, bgfx::UniformType::Vec4);
}
else if (compareString(type, "vec3") == 0)
{
u.type = Shader::Uniform::VEC3;
u.handle = bgfx::createUniform(name, bgfx::UniformType::Vec4);
}
else
{
g_log_error.log("Renderer") << "Unknown uniform type " << type << " in " << shader->getPath().c_str();
}
}
bool operator() (const std::string& a, const std::string& b) const
{
return compareString(a.c_str(), b.c_str()) < 0;
}
bool ParserTable::loadFromData(const char* data, size_t size)
{
if (compareString(data, size, PARSER_TABLE)) data += strlen(PARSER_TABLE);
//uchar version = *data;
++data;
data += 8; // timestamp align to 8 bytes
size_t vtCount = *reinterpret_cast<const size_t*>(data);
data += sizeof(size_t);
size_t vnCount = *reinterpret_cast<const size_t*>(data);
data += sizeof(size_t);
size_t rulesCount = *reinterpret_cast<const size_t*>(data);
data += sizeof(size_t);
size_t itemCount = *reinterpret_cast<const size_t*>(data);
data += sizeof(size_t);
iStart = *reinterpret_cast<const uint*>(data);
data += sizeof(uint);
vts.reserve(vtCount);
vns.reserve(vnCount);
rules.reserve(rulesCount);
items.reserve(itemCount);
table.reserve(itemCount * (vtCount + 1 + vnCount));
for (size_t i = 0; i < itemCount * (vtCount + 1 + vnCount); ++i)
{
pair<uchar, ushort> p;
p.first = *data;
++data;
p.second = *reinterpret_cast<const ushort*>(data);
data += sizeof(ushort);
table.push_back(p);
}
for (size_t i = 0; i < vtCount; ++i)
{
Production::Item item(&ruleContext);
item.loadFromData(data);
vts.push_back(item);
}
for (size_t i = 0; i < vnCount; ++i)
{
Production::Item item;
item.loadFromData(data);
vns.push_back(item);
}
for (size_t i = 0; i < rulesCount; ++i)
{
Production p;
p.loadFromData(data, &ruleContext);
rules.push_back(p);
}
for (size_t i = 0; i < itemCount; ++i)
{
items.push_back(*reinterpret_cast<const uint*>(data));
data += sizeof(uint);
}
return true;
}
void chladniRC::onSerialBuffer(const ofx::IO::SerialBufferEventArgs& args){
// Buffers will show up here when the marker character is found.
string message(args.getBuffer().toString());
//serialMessages.push_back(message);
// get pingback
string compareString("pingback:");
if(message.length()>=compareString.length() ){
if( message.compare(0,compareString.length(),compareString,0,compareString.length())==0){
arduinoLastPingReturn = message.substr(compareString.length()-1,message.npos);
return;
}
}
//
compareString = "EVStatus:";
if(message.length()>=compareString.length() ){
if( message.compare(0,compareString.length(),compareString,0,compareString.length())==0){
string rawValue = message.substr(compareString.length(),message.npos);
auto dash = rawValue.find("-");
if(dash != rawValue.npos){
int valveID = ofToInt( rawValue.substr(0,dash) );
if( valveID>=0 && valveID<KM_CHLADNI_NUM_ELECTROVALVES){
int valveValue = ofToInt( rawValue.substr(dash+1,rawValue.npos-(dash+1) ) );
waterControlSettings.waterFlowRate[valveID] = ((float)valveValue)/255.f;
}
}
return;
}
}
// get the manual LED strip value
compareString = "ledStripIntensityManu:";
if(message.length()>=compareString.length() ){
if( message.compare(0,compareString.length(),compareString,0,compareString.length())==0){
string rawValue = message.substr(compareString.length(),message.npos);
auto dash = rawValue.find("-");
if(dash != rawValue.npos){
int lightID = ofToInt( rawValue.substr(0,dash) );
if( lightID>=0 && lightID<KM_CHLADNI_NUM_LED_STRIPS){
int lightValue = ofToInt( rawValue.substr(dash+1,rawValue.npos-(dash+1) ) );
waterControlSettings.LEDStripsIntensityManu[lightID] = ((float)lightValue)/255.f;
}
}
return;
}
}
// still not returned? --> unrecognised message
cout << "Unrecognised chladni SERIAL message:\t" << message << endl;
}
static unsigned int handleAlpha(ruleset *tree, char *sid, char *mid, char *state, alpha *alphaNode, jsonProperty *allProperties,
void **rulesBinding, unsigned short actionType, unsigned short *commandCount) {
alpha *alphaStack[MAX_STACK_SIZE];
jsonProperty *propertyStack[MAX_STACK_SIZE];
alphaStack[0] = alphaNode;
propertyStack[0] = NULL;
alpha *currentAlpha;
jsonProperty *currentProperty;
unsigned short top = 1;
unsigned int result = ERR_EVENT_NOT_HANDLED;
unsigned int propertyHash = 1;
while (top > 0) {
--top;
currentAlpha = alphaStack[top];
currentProperty = propertyStack[top];
unsigned char alphaOp = currentAlpha->operator;
unsigned char propertyMatch = 1;
if (alphaOp != OP_NEX && alphaOp != OP_EX && alphaOp != OP_TYPE)
{
char *propertyLast = currentProperty->lastValue;
char *propertyFirst = currentProperty->firstValue;
unsigned char propertyType = currentProperty->type;
char temp;
if (!currentProperty->isMaterial) {
switch(propertyType) {
case JSON_INT:
++propertyLast;
temp = propertyLast[0];
propertyLast[0] = '\0';
currentProperty->value.i = atol(propertyFirst);
propertyLast[0] = temp;
break;
case JSON_DOUBLE:
++propertyLast;
temp = propertyLast[0];
propertyLast[0] = '\0';
currentProperty->value.i = atof(propertyFirst);
propertyLast[0] = temp;
break;
case JSON_BOOL:
++propertyLast;
unsigned int leftLength = propertyLast - propertyFirst;
unsigned char b = 1;
if (leftLength == 5 && strncmp("false", propertyFirst, 5)) {
b = 0;
}
currentProperty->value.b = b;
break;
}
currentProperty->isMaterial = 1;
}
unsigned short type = propertyType << 8;
type = type + currentAlpha->right.type;
int leftLength;
switch(type) {
case COMP_BOOL_BOOL:
propertyMatch = compareBool(currentProperty->value.b, currentAlpha->right.value.b, alphaOp);
break;
case COMP_BOOL_INT:
propertyMatch = compareInt(currentProperty->value.b, currentAlpha->right.value.i, alphaOp);
break;
case COMP_BOOL_DOUBLE:
propertyMatch = compareDouble(currentProperty->value.b, currentAlpha->right.value.d, alphaOp);
break;
case COMP_BOOL_STRING:
propertyMatch = compareString(propertyFirst, propertyLast,
&tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp);
break;
case COMP_INT_BOOL:
propertyMatch = compareInt(currentProperty->value.i, currentAlpha->right.value.b, alphaOp);
break;
case COMP_INT_INT:
propertyMatch = compareInt(currentProperty->value.i, currentAlpha->right.value.i, alphaOp);
break;
case COMP_INT_DOUBLE:
propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.d, alphaOp);
break;
case COMP_INT_STRING:
propertyMatch = compareString(propertyFirst, propertyLast,
&tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp);
break;
case COMP_DOUBLE_BOOL:
propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.b, alphaOp);
break;
case COMP_DOUBLE_INT:
propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.i, alphaOp);
break;
case COMP_DOUBLE_DOUBLE:
propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.d, alphaOp);
break;
case COMP_DOUBLE_STRING:
propertyMatch = compareString(propertyFirst, propertyLast,
&tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp);
break;
case COMP_STRING_BOOL:
if (currentAlpha->right.value.b) {
propertyMatch = compareString(propertyFirst, propertyLast, "true", alphaOp);
}
else {
propertyMatch = compareString(propertyFirst, propertyLast, "false", alphaOp);
}
break;
case COMP_STRING_INT:
{
leftLength = propertyLast - propertyFirst + 1;
char rightStringInt[leftLength];
snprintf(rightStringInt, leftLength, "%ld", currentAlpha->right.value.i);
propertyMatch = compareString(propertyFirst, propertyLast, rightStringInt, alphaOp);
}
break;
case COMP_STRING_DOUBLE:
{
leftLength = propertyLast - propertyFirst + 1;
char rightStringDouble[leftLength];
snprintf(rightStringDouble, leftLength, "%f", currentAlpha->right.value.d);
propertyMatch = compareString(propertyFirst, propertyLast, rightStringDouble, alphaOp);
break;
}
case COMP_STRING_STRING:
propertyMatch = compareString(propertyFirst, propertyLast,
&tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp);
break;
}
}
if (propertyMatch) {
unsigned int nextLength = currentAlpha->nextLength;
unsigned int nextOffset = currentAlpha->nextOffset;
for (unsigned int i = 0; i < nextLength; ++i) {
node *currentNode = &tree->nodePool[tree->nextPool[nextOffset + i]];
unsigned int nodeHash;
if (currentNode->type != NODE_ALPHA) {
result = handleBeta(tree, sid, mid, state, currentNode, rulesBinding, actionType, commandCount);
}
else {
nodeHash = currentNode->value.a.hash;
propertyHash = 1;
for (int ii = 0; propertyHash && (propertyHash != nodeHash) && (ii < MAX_CONFLICTS); ++ii) {
currentProperty = &allProperties[(nodeHash & HASH_MASK) + (ii * MAX_BUCKET_LENGTH)];
propertyHash = currentProperty->hash;
}
if (((nodeHash == propertyHash) && (currentNode->value.a.operator != OP_NEX)) ||
((nodeHash != propertyHash) && (currentNode->value.a.operator == OP_NEX))) {
if (top == MAX_STACK_SIZE) {
return ERR_MAX_STACK_SIZE;
}
alphaStack[top] = ¤tNode->value.a;
propertyStack[top] = currentProperty;
++top;
}
}
}
}
}
return result;
}
void ApplicationModel::updateChildItems(void)
{
ModulePContainer modules = parentWindow->manager.getKnowledgeBase()->getModules(application);
CnnContainer connections = parentWindow->manager.getKnowledgeBase()->getConnections(application);
ApplicaitonPContainer applications = parentWindow->manager.getKnowledgeBase()->getApplications(application);
int index = 0; //index = (index/900)*100+50;
CnnIterator citr;
for(citr=connections.begin(); citr<connections.end(); citr++)
{
Connection baseCon = *citr;
GraphicModel model = baseCon.getModelBase();
InputData* input = NULL;
OutputData* output = NULL;
Glib::RefPtr<PortModel> source(NULL);
Glib::RefPtr<PortModel> dest(NULL);
findInputOutputData((*citr), modules, input, output);
if(output)
source = findModelFromOutput(output);
else
{
Glib::RefPtr<ExternalPortModel> extPort;
bool bExist = false;
for(int i=0; i<get_n_children(); i++)
{
extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(get_child(i));
if(extPort && compareString(extPort->getPort(), baseCon.from()))
{
source = extPort;
bExist = true;
break;
}
}
if(!bExist)
{
source = ExternalPortModel::create(parentWindow, OUTPUTD, (*citr).from(), true);
add_child(source);
double x ,y;
if(model.points.size() > 1)
{
x = model.points[1].x - Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getWidth()
- bounds.get_x1()+ITEMS_MARGIE;
y = model.points[1].y - Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getHeight()/2.0
- bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE;
source->set_property("x", x);
source->set_property("y", y);
}
else
{
x = 10;
y = index;
source->set_property("x", 10);
source->set_property("y", index);
}
double end_x, end_y;
double start_x;
Goocanvas::Points points = poly->property_points().get_value();
points.get_coordinate(4, end_x, end_y);
points.get_coordinate(5, start_x, end_y);
double port_w = Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getWidth();
double port_h = Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getHeight();
if((x + port_w + ITEMS_MARGIE) >= end_x)
width = x + port_w + ITEMS_MARGIE;
if((y + port_h + ITEMS_MARGIE) >= end_y)
height = y + port_h + ITEMS_MARGIE;
double minx = start_x;
if(x < start_x)
{
minx = x - ITEMS_MARGIE;
text->translate(-abs(start_x-x)-ITEMS_MARGIE, 0);
}
points.set_coordinate(0, minx, 0);
points.set_coordinate(1, text_w+TEXT_MARGINE*2+minx, 0);
points.set_coordinate(2, text_w+TEXT_MARGINE*2+minx, text_h+TEXT_MARGINE);
points.set_coordinate(3, width, text_h+TEXT_MARGINE);
points.set_coordinate(4, width, height);
points.set_coordinate(5, minx, height);
poly->property_points().set_value(points);
Goocanvas::Points points3(3);
points3.set_coordinate(0, width, text_h+TEXT_MARGINE);
points3.set_coordinate(1, width, height);
points3.set_coordinate(2, minx, height);
shadow->property_points().set_value(points3);
}
index+=40;
}
if(input)
dest = findModelFromInput(input);
else
{
Glib::RefPtr<ExternalPortModel> extPort;
bool bExist = false;
for(int i=0; i<get_n_children(); i++)
{
extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(get_child(i));
if(extPort && compareString(extPort->getPort(), baseCon.to()))
{
dest = extPort;
bExist = true;
break;
}
}
if(!bExist)
{
double x,y;
dest = ExternalPortModel::create(parentWindow, INPUTD, (*citr).to(), true);
add_child(dest);
size_t size = model.points.size();
if(size > 2)
{
x = model.points[size-1].x-bounds.get_x1()+ITEMS_MARGIE;
y = model.points[size-1].y - Glib::RefPtr<ExternalPortModel>::cast_dynamic(dest)->getHeight()/2.0
- bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE;
dest->set_property("x", x);
dest->set_property("y", y);
}
else
{
x = 400;
y = index;
dest->set_property("x", x);
dest->set_property("y", y);
}
double end_x, end_y;
Goocanvas::Points points = poly->property_points().get_value();
points.get_coordinate(4, end_x, end_y);
double port_w = Glib::RefPtr<ExternalPortModel>::cast_dynamic(dest)->getWidth();
double port_h = Glib::RefPtr<ExternalPortModel>::cast_dynamic(dest)->getHeight();
if((x + port_w + ITEMS_MARGIE) >= end_x)
width = x + port_w + ITEMS_MARGIE;
if((y + port_h + ITEMS_MARGIE) >= end_y)
height = y + port_h + ITEMS_MARGIE;
points.set_coordinate(3, width, text_h+TEXT_MARGINE);
points.set_coordinate(4, width, height);
points.get_coordinate(5, end_x, end_y);
points.set_coordinate(5, end_x, height);
poly->property_points().set_value(points);
Goocanvas::Points points3(3);
points3.set_coordinate(0, width, text_h+TEXT_MARGINE);
points3.set_coordinate(1, width, height);
points3.set_coordinate(2, end_x, height);
shadow->property_points().set_value(points3);
}
}
if(source && dest)
{
Glib::RefPtr<ArrowModel> arrow = ArrowModel::create(parentWindow, source, dest, &baseCon, this);
add_child(arrow);
int size = model.points.size();
for(int i=2; i<size-1; i++)
arrow->addMidPoint(model.points[i].x-bounds.get_x1()+ITEMS_MARGIE,
model.points[i].y-bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE, i-2);
arrow->setSelected(false);
if(size)
arrow->setLabelPosition(model.points[0].x-bounds.get_x1()+ITEMS_MARGIE,
model.points[0].y-bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE);
}
}
}
void ResourceWindow::updateWidget()
{
m_refTreeModel->clear();
Gtk::TreeModel::Row row;
Gtk::TreeModel::Row childrow;
// Gtk::TreeModel::Row cchildrow;
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Name";
row[m_Columns.m_col_value] = m_pComputer->getName();
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Description";
row[m_Columns.m_col_value] = m_pComputer->getDescription();
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Disable";
if(!m_pComputer->getDisable())
{
row[m_Columns.m_col_value] = "No";
row.set_value(0, Gdk::Pixbuf::create_from_data(computer_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
computer_ico.width,
computer_ico.height,
computer_ico.bytes_per_pixel*computer_ico.width));
}
else
{
row[m_Columns.m_col_value] = "Yes";
row.set_value(0, Gdk::Pixbuf::create_from_data(computer_disable_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
computer_disable_ico.width,
computer_disable_ico.height,
computer_disable_ico.bytes_per_pixel*computer_disable_ico.width));
}
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Availablity";
if(m_pComputer->getAvailability())
{
row[m_Columns.m_col_value] = "Yes";
row.set_value(0, Gdk::Pixbuf::create_from_data(yesres_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
yesres_ico.width,
yesres_ico.height,
yesres_ico.bytes_per_pixel*yesres_ico.width));
}
else
{
row[m_Columns.m_col_value] = "No";
row.set_value(0, Gdk::Pixbuf::create_from_data(nores_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
nores_ico.width,
nores_ico.height,
nores_ico.bytes_per_pixel*nores_ico.width));
return;
}
// platform
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Platform";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(module_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
module_ico.width,
module_ico.height,
module_ico.bytes_per_pixel*module_ico.width));
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Name";
childrow[m_Columns.m_col_value] = m_pComputer->getPlatform().getName();
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Distribution";
childrow[m_Columns.m_col_value] = m_pComputer->getPlatform().getDistribution();
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Release";
childrow[m_Columns.m_col_value] = m_pComputer->getPlatform().getRelease();
// processor
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Processor";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(processor_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
processor_ico.width,
processor_ico.height,
processor_ico.bytes_per_pixel*processor_ico.width));
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Model";
childrow[m_Columns.m_col_value] = m_pComputer->getProcessor().getModel();
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Architecture";
childrow[m_Columns.m_col_value] = m_pComputer->getProcessor().getArchitecture();
char buff[64];
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Cores";
sprintf(buff, "%d", (int)m_pComputer->getProcessor().getCores());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Siblings";
sprintf(buff, "%d", (int)m_pComputer->getProcessor().getSiblings());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Frequency";
sprintf(buff, "%.2f", (float)m_pComputer->getProcessor().getFrequency());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
// CPU Load
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "CPU Load";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(cpuload_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
cpuload_ico.width,
cpuload_ico.height,
cpuload_ico.bytes_per_pixel*cpuload_ico.width));
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Load instant";
if(compareString(m_pComputer->getPlatform().getName(), "WINDOWS"))
sprintf(buff, "%.1f%%", (float)m_pComputer->getProcessor().getCPULoad().loadAverageInstant);
else
{
float sibling = (float)m_pComputer->getProcessor().getSiblings();
if(!sibling) sibling = 1.0F;
float loadP = (float)(m_pComputer->getProcessor().getCPULoad().loadAverageInstant / sibling)*100.0F;
if(loadP > 100.0F) loadP = 100.0F;
sprintf(buff, "%.1f%%", loadP);
}
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
float sibling = (float)m_pComputer->getProcessor().getSiblings();
if(!sibling) sibling = 1.0F;
float load1P = ((float)m_pComputer->getProcessor().getCPULoad().loadAverage1 / sibling)*100.0F;
if(load1P > 100.0F) load1P = 100.0F;
float load5P = ((float)m_pComputer->getProcessor().getCPULoad().loadAverage5 / sibling)*100.0F;
if(load5P > 100.0F) load5P = 100.0F;
float load15P = ((float)m_pComputer->getProcessor().getCPULoad().loadAverage15 / sibling)*100.0F;
if(load15P > 100.0F) load15P = 100.0F;
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Load average 1";
sprintf(buff, "%.1f%%", load1P);
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Load average 5";
sprintf(buff, "%.1f%%", load5P);
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Load average 15";
sprintf(buff, "%.1f%%", load15P);
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
m_TreeView.expand_row(m_refTreeModel->get_path(row), true);
// Memory
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Memory";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(memory_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
memory_ico.width,
memory_ico.height,
memory_ico.bytes_per_pixel*memory_ico.width));
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Total space";
sprintf(buff, "%ldKB", (long)m_pComputer->getMemory().getTotalSpace());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Free space";
sprintf(buff, "%ldKB", (long)m_pComputer->getMemory().getFreeSpace());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
// Storage
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Storage";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(storage_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
storage_ico.width,
storage_ico.height,
storage_ico.bytes_per_pixel*storage_ico.width));
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Total space";
sprintf(buff, "%ldKB", (long)m_pComputer->getStorage().getTotalSpace());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = "Free space";
sprintf(buff, "%ldKB", (long)m_pComputer->getStorage().getFreeSpace());
childrow[m_Columns.m_col_value] = Glib::ustring(buff);
// Peripherals
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Peripheral devices";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(device_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
device_ico.width,
device_ico.height,
device_ico.bytes_per_pixel*device_ico.width));
for(int i=0; i<m_pComputer->peripheralCount(); i++)
{
childrow = *(m_refTreeModel->append(row.children()));
childrow[m_Columns.m_col_name] = m_pComputer->getPeripheralAt(i).getTypeName();
childrow[m_Columns.m_col_value] = m_pComputer->getPeripheralAt(i).getName();
}
// Processes
row = *(m_refTreeModel->append());
row[m_Columns.m_col_name] = "Processes";
row[m_Columns.m_col_value] = "";
row.set_value(0, Gdk::Pixbuf::create_from_data(process_ico.pixel_data,
Gdk::COLORSPACE_RGB,
true,
8,
process_ico.width,
process_ico.height,
process_ico.bytes_per_pixel*process_ico.width));
ProcessContainer processes = m_pComputer->getProcesses();
for(unsigned int i=0; i<processes.size(); i++)
{
childrow = *(m_refTreeModel->append(row.children()));
char buff[64];
sprintf(buff, "%d", processes[i].pid);
childrow[m_Columns.m_col_name] = Glib::ustring(buff);
childrow[m_Columns.m_col_value] = processes[i].command;
}
}
