void BasicHDT::loadFromSeveralHDT(const char **fileNames, size_t numFiles, string baseUri, ProgressListener *listener)
{
try {
// Make sure that URI starts and ends with <>
if(baseUri.at(0)!='<')
baseUri = '<'+baseUri;
if(baseUri.at(baseUri.length()-1)!='>')
baseUri.append(">");
IntermediateListener iListener(listener);
iListener.setRange(0,50);
loadDictionaryFromHDTs(fileNames, numFiles, baseUri.c_str(), &iListener);
iListener.setRange(50,99);
loadTriplesFromHDTs(fileNames, numFiles, baseUri.c_str(), &iListener);
fillHeader(baseUri);
}catch (const char *e) {
cout << "Catch exception load: " << e << endl;
deleteComponents();
createComponents();
throw e;
} catch (char *e) {
cout << "Catch exception load: " << e << endl;
deleteComponents();
createComponents();
throw e;
}
}
void sJarvisNode::socketDisconected()
{
disconnect(&m_tcpClient,SIGNAL(socket_rx(QByteArray)),this,SLOT(data_rx(QByteArray)));
m_pingTimer.stop();
m_initTimer.stop();
deleteComponents();
emit disconnected();
}
int main(int argc, char** argv) {
int running = GL_TRUE;
// Initialize GLFW
if (!glfwInit()) {
exit(EXIT_FAILURE);
}
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
// glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
// glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1);
// glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL
// Open an OpenGL window
if (!glfwOpenWindow(1280, 720, 0, 0, 0, 0, 32, 0, GLFW_WINDOW)) {
glfwTerminate();
return EXIT_FAILURE;
}
glfwSetWindowTitle("Capivara-GL Test");
// glEnable(GL_LINE_SMOOTH);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
// glLineWidth(1.5f);
glfwEnable(GLFW_KEY_REPEAT);
glfwEnable(GLFW_STICKY_KEYS);
glEnable(GL_MULTISAMPLE);
glDisable(GL_DEPTH_TEST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
initComponents();
glfwSetKeyCallback(keyCallback);
glfwSetCharCallback(charCallback);
glfwSetWindowRefreshCallback(display);
glfwSetWindowSizeCallback(reshape);
glfwSetMousePosCallback(mousePosition);
glfwSetMouseButtonCallback(mouseButton);
//-------------------------------------------------------------------------
// Main loop
while (running) {
display();
glfwSwapBuffers();
running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
}
deleteComponents();
// Close window and terminate GLFW
glfwTerminate();
return EXIT_SUCCESS;
}
void BasicHDT::loadFromHDT(std::istream & input, ProgressListener *listener)
{
try {
ControlInformation controlInformation;
IntermediateListener iListener(listener);
// Load Global ControlInformation.
controlInformation.load(input);
std::string hdtFormat = controlInformation.getFormat();
if(hdtFormat!=HDTVocabulary::HDT_CONTAINER) {
throw "This software cannot open this version of HDT File.";
}
// Load header
iListener.setRange(0,5);
controlInformation.load(input);
delete header;
header = HDTFactory::readHeader(controlInformation);
header->load(input, controlInformation, &iListener);
//Load Dictionary.
iListener.setRange(5, 60);
controlInformation.load(input);
delete dictionary;
dictionary = HDTFactory::readDictionary(controlInformation);
dictionary->load(input, controlInformation, &iListener);
// Load Triples
iListener.setRange(60,100);
controlInformation.load(input);
delete triples;
triples = HDTFactory::readTriples(controlInformation);
triples->load(input, controlInformation, &iListener);
} catch (const char *ex) {
cout << "Exception loading HDT: " << ex;
deleteComponents();
createComponents();
throw ex;
} catch (char *ex) {
cout << "Exception loading HDT: " << ex;
deleteComponents();
createComponents();
throw ex;
}
}
BasicHDT::~BasicHDT() {
deleteComponents();
if(mappedHDT) {
delete mappedHDT;
}
if(mappedIndex) {
delete mappedIndex;
}
}
static void
writeByteComponents(JNIEnv *env, PacketOutputStream *out,
jarray array, jint index, jint length)
{
jbyte *components;
components = newComponents(out, length, sizeof(jbyte));
if (components != NULL) {
jint i;
JNI_FUNC_PTR(env,GetByteArrayRegion)(env, array, index, length, components);
for (i = 0; i < length; i++) {
(void)outStream_writeByte(out, components[i]);
}
deleteComponents(components);
}
}
DependenciesSolvingResult ComponentInstaller::tryToInstall(const QStringList &componentNames)
{
deleteComponents();
// Add existed componens to resolve componens for install
IComponentDependenciesPtr dependencies(createDependencies());
for (IComponent *comp : m_existedComponents)
dependencies->addComponent(comp);
QList<IComponent *> discoveredComponents = discoverComponents();
// Select components to install from the all discovered components
QList<IComponent *> toInstall;
for (IComponent *comp : discoveredComponents) {
dependencies->addComponent(comp);
if (componentNames.contains(comp->name()))
toInstall.push_back(comp);
}
// Find all parents for components to install
DependenciesSolvingResult result = dependencies->completeListWithChildren(toInstall);
if (!result.orphans().isEmpty()) {
qDeleteAll(toInstall);
return result;
}
// Return only components that have to be installed
for (IComponent *comp : result.ordered()) {
if (toInstall.contains(comp))
continue;
if (discoveredComponents.contains(comp))
toInstall.push_back(comp);
}
// Delete unused components
for (IComponent *comp : discoveredComponents) {
if (!toInstall.contains(comp))
delete comp;
}
m_componentsToInstall = toInstall;
return DependenciesSolvingResult(m_componentsToInstall);
}
ThemeComponent::~ThemeComponent()
{
deleteComponents();
}
void ThemeComponent::readXML(std::string path)
{
if(mPath == path)
return;
setDefaults();
deleteComponents();
mPath = path;
if(path.empty())
return;
LOG(LogInfo) << "Loading theme \"" << path << "\"...";
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(path.c_str());
if(!result)
{
LOG(LogError) << "Error parsing theme \"" << path << "\"!\n" << " " << result.description();
return;
}
pugi::xml_node root;
if(!mDetailed)
{
//if we're using the basic view, check if there's a basic version of the theme
root = doc.child("basicTheme");
}
if(!root)
{
root = doc.child("theme");
}
if(!root)
{
LOG(LogError) << "No theme tag found in theme \"" << path << "\"!";
return;
}
//load non-component theme stuff
mColorMap["primary"] = resolveColor(root.child("listPrimaryColor").text().get(), mColorMap["primary"]);
mColorMap["secondary"] = resolveColor(root.child("listSecondaryColor").text().get(), mColorMap["secondary"]);
mColorMap["selector"] = resolveColor(root.child("listSelectorColor").text().get(), mColorMap["selector"]);
mColorMap["selected"] = resolveColor(root.child("listSelectedColor").text().get(), mColorMap["selected"]);
mColorMap["description"] = resolveColor(root.child("descColor").text().get(), mColorMap["description"]);
mColorMap["fastSelect"] = resolveColor(root.child("fastSelectColor").text().get(), mColorMap["fastSelect"]);
mBoolMap["hideHeader"] = root.child("hideHeader") != 0;
mBoolMap["hideDividers"] = root.child("hideDividers") != 0;
//GuiBox theming data
mBoxData.backgroundPath = expandPath(root.child("boxBackground").text().get());
mBoxData.backgroundTiled = root.child("boxBackgroundTiled") != 0;
mBoxData.horizontalPath = expandPath(root.child("boxHorizontal").text().get());
mBoxData.horizontalTiled = root.child("boxHorizontalTiled") != 0;
mBoxData.verticalPath = expandPath(root.child("boxVertical").text().get());
mBoxData.verticalTiled = root.child("boxVerticalTiled") != 0;
mBoxData.cornerPath = expandPath(root.child("boxCorner").text().get());
//list stuff
mBoolMap["listCentered"] = !root.child("listLeftAlign");
mFloatMap["listOffsetX"] = strToFloat(root.child("listOffsetX").text().get(), mFloatMap["listOffsetX"]);
mFloatMap["listTextOffsetX"] = strToFloat(root.child("listTextOffsetX").text().get(), mFloatMap["listTextOffsetX"]);
//game image stuff
std::string artPos = root.child("gameImagePos").text().get();
std::string artDim = root.child("gameImageDim").text().get();
std::string artOrigin = root.child("gameImageOrigin").text().get();
std::string artPosX, artPosY, artWidth, artHeight, artOriginX, artOriginY;
splitString(artPos, ' ', &artPosX, &artPosY);
splitString(artDim, ' ', &artWidth, &artHeight);
splitString(artOrigin, ' ', &artOriginX, &artOriginY);
mFloatMap["gameImageOffsetX"] = resolveExp(artPosX, mFloatMap["gameImageOffsetX"]);
mFloatMap["gameImageOffsetY"] = resolveExp(artPosY, mFloatMap["gameImageOffsetY"]);
mFloatMap["gameImageWidth"] = resolveExp(artWidth, mFloatMap["gameImageWidth"]);
mFloatMap["gameImageHeight"] = resolveExp(artHeight, mFloatMap["gameImageHeight"]);
mFloatMap["gameImageOriginX"] = resolveExp(artOriginX, mFloatMap["gameImageOriginX"]);
mFloatMap["gameImageOriginY"] = resolveExp(artOriginY, mFloatMap["gameImageOriginY"]);
mStringMap["imageNotFoundPath"] = expandPath(root.child("gameImageNotFound").text().get());
//sounds
mSoundMap["menuScroll"]->loadFile(expandPath(root.child("menuScrollSound").text().get()));
mSoundMap["menuSelect"]->loadFile(expandPath(root.child("menuSelectSound").text().get()));
mSoundMap["menuBack"]->loadFile(expandPath(root.child("menuBackSound").text().get()));
mSoundMap["menuOpen"]->loadFile(expandPath(root.child("menuOpenSound").text().get()));
//fonts
mListFont = resolveFont(root.child("listFont"), Font::getDefaultPath(), Renderer::getDefaultFont(Renderer::MEDIUM)->getSize());
mDescFont = resolveFont(root.child("descriptionFont"), Font::getDefaultPath(), Renderer::getDefaultFont(Renderer::SMALL)->getSize());
mFastSelectFont = resolveFont(root.child("fastSelectFont"), Font::getDefaultPath(), Renderer::getDefaultFont(Renderer::LARGE)->getSize());
//actually read the components
createComponentChildren(root, this);
LOG(LogInfo) << "Theme loading complete.";
}
ComponentInstaller::~ComponentInstaller()
{
deleteComponents();
}
void sJarvisNode::closeTCP()
{
m_tcpClient.close();
m_pingTimer.stop();
deleteComponents();
}
void sJarvisNode::sendGetComponents()
{
deleteComponents();
m_initDone = false;
send(encodeNodeMsg(QStringList(QString(C_GETCOMPONENTS))));
}