Пример #1
0
 TGUI_API Widget::Ptr loadClickableWidget(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
 {
     if (widget)
         return loadWidget(node, widget);
     else
         return loadWidget(node, std::make_shared<ClickableWidget>());
 }
Пример #2
0
    TGUI_API Widget::Ptr loadTab(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Tab::Ptr tab;
        if (widget)
            tab = std::static_pointer_cast<Tab>(widget);
        else
            tab = std::make_shared<Tab>();

        loadWidget(node, tab);

        if (node->propertyValuePairs["tabs"])
        {
            if (!node->propertyValuePairs["tabs"]->listNode)
                throw Exception{"Failed to parse 'Tabs' property, expected a list as value"};

            for (auto& tabText : node->propertyValuePairs["tabs"]->valueList)
                tab->add(Deserializer::deserialize(ObjectConverter::Type::String, tabText).getString());
        }

        if (node->propertyValuePairs["maximumtabwidth"])
            tab->setMaximumTabWidth(tgui::stof(node->propertyValuePairs["maximumtabwidth"]->value));
        if (node->propertyValuePairs["textsize"])
            tab->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));
        if (node->propertyValuePairs["tabheight"])
            tab->setTabHeight(tgui::stof(node->propertyValuePairs["tabheight"]->value));
        if (node->propertyValuePairs["selected"])
            tab->select(tgui::stoi(node->propertyValuePairs["selected"]->value));

        return tab;
    }
Пример #3
0
    TGUI_API Widget::Ptr loadTextBox(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        TextBox::Ptr textBox;
        if (widget)
            textBox = std::static_pointer_cast<TextBox>(widget);
        else
            textBox = std::make_shared<TextBox>();

        loadWidget(node, textBox);

        if (node->propertyValuePairs["text"])
            textBox->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["textsize"])
            textBox->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));
        if (node->propertyValuePairs["maximumcharacters"])
            textBox->setMaximumCharacters(tgui::stoi(node->propertyValuePairs["maximumcharacters"]->value));
        if (node->propertyValuePairs["readonly"])
            textBox->setReadOnly(parseBoolean(node->propertyValuePairs["readonly"]->value));

        for (auto& childNode : node->children)
        {
            if (toLower(childNode->name) == "scrollbar")
                textBox->setScrollbar(std::static_pointer_cast<Scrollbar>(WidgetLoader::getLoadFunction("scrollbar")(childNode)));
        }
        REMOVE_CHILD("scrollbar");

        return textBox;
    }
Пример #4
0
    void WidgetLoader::load(Container::Ptr parent, std::stringstream& stream)
    {
        auto rootNode = DataIO::parse(stream);

        if (rootNode->propertyValuePairs.size() != 0)
            loadWidget(rootNode, parent);

        for (auto& node : rootNode->children)
        {
            auto nameSeparator = node->name.find('.');
            auto widgetType = node->name.substr(0, nameSeparator);
            auto& loadFunction = m_loadFunctions[toLower(widgetType)];
            if (loadFunction)
            {
                std::string className;
                if (nameSeparator != std::string::npos)
                {
                    if ((node->name.size() >= nameSeparator + 2) && (node->name[nameSeparator+1] == '"') && (node->name.back() == '"'))
                        className = Deserializer::deserialize(ObjectConverter::Type::String, node->name.substr(nameSeparator + 1)).getString();
                    else
                        className = node->name.substr(nameSeparator + 1);
                }

                tgui::Widget::Ptr widget = loadFunction(node);
                parent->add(widget, className);
            }
            else
                throw Exception{"No load function exists for widget type '" + widgetType + "'."};
        }
    }
Пример #5
0
void EmbeddedFilesDock::fillInfo()
{
	if (!m_table) // use delayed initialization for faster startup if not all docks are visible
		loadWidget();

    m_table->setHorizontalHeaderLabels(
        QStringList() << tr("Name") << tr("Description") << tr("Size") << tr("Creation date")
                      << tr("Modification date") << tr("Checksum"));
    if (!document()->hasEmbeddedFiles()) {
        m_table->setItem(0, 0, new QTableWidgetItem(tr("No files")));
        return;
    }

    const QList<Poppler::EmbeddedFile*> files = document()->embeddedFiles();
    m_table->setRowCount(files.count());
    int i = 0;
    Q_FOREACH(Poppler::EmbeddedFile *file, files) {
        m_table->setItem(i, 0, new QTableWidgetItem(file->name()));
        m_table->setItem(i, 1, new QTableWidgetItem(file->description()));
        m_table->setItem(i, 2, new QTableWidgetItem(QString::number(file->size())));
        m_table->setItem(i, 3, new QTableWidgetItem(file->createDate().toString(Qt::SystemLocaleDate)));
        m_table->setItem(i, 4, new QTableWidgetItem(file->modDate().toString(Qt::SystemLocaleDate)));
        const QByteArray checksum = file->checksum();
        const QString checksumString = !checksum.isEmpty() ? QString::fromAscii(checksum.toHex()) : QString::fromLatin1("n/a");
        m_table->setItem(i, 5, new QTableWidgetItem(checksumString));
        ++i;
    }
Пример #6
0
void GUI::loadWidget(const Aurora::GFFStruct &strct, Widget *parent,
		float width, float height) {

	WidgetContext ctx(strct, parent);

	createWidget(ctx);

	if (width  <= 0.0)
		width  = ctx.widget->getWidth();
	if (height <= 0.0)
		height = ctx.widget->getHeight();

	float wX, wY, wZ;
	ctx.widget->getPosition(wX, wY, wZ);

	wX = wX - (width / 2.0);
	wY = ((height - wY) - ctx.widget->getHeight()) - (height / 2.0);
	wZ = _widgetZ + wZ;

	ctx.widget->setPosition(wX, wY, wZ);

	_widgetZ -= 1.0;

	addWidget(ctx.widget);

	// Go down to the children
	if (ctx.strct->hasField("CONTROLS")) {
		const Aurora::GFFList &children = ctx.strct->getList("CONTROLS");

		for (Aurora::GFFList::const_iterator c = children.begin(); c != children.end(); ++c)
			loadWidget(**c, ctx.widget, width, height);
	}
}
Пример #7
0
    TGUI_API Widget::Ptr loadContainer(std::shared_ptr<DataIO::Node> node, Container::Ptr container)
    {
        assert(container != nullptr);
        loadWidget(node, container);

        for (auto& childNode : node->children)
        {
            auto nameSeparator = childNode->name.find('.');
            auto widgetType = childNode->name.substr(0, nameSeparator);
            auto& loadFunction = WidgetLoader::getLoadFunction(toLower(widgetType));
            if (loadFunction)
            {
                std::string className;
                if (nameSeparator != std::string::npos)
                {
                    if ((childNode->name.size() >= nameSeparator + 2) && (childNode->name[nameSeparator+1] == '"') && (childNode->name.back() == '"'))
                        className = Deserializer::deserialize(ObjectConverter::Type::String, childNode->name.substr(nameSeparator + 1)).getString();
                    else
                        className = childNode->name.substr(nameSeparator + 1);
                }

                tgui::Widget::Ptr childWidget = loadFunction(childNode);
                container->add(childWidget, className);
            }
            else
                throw Exception{"No load function exists for widget type '" + widgetType + "'."};
        }

        return container;
    }
Пример #8
0
void GUI::loadWidget(const Aurora::GFF3Struct &strct, Widget *parent) {

	WidgetContext ctx(strct, parent);

	createWidget(ctx);

	if (_guiWidth  <= 0.0f)
		_guiWidth  = ctx.widget->getWidth();
	if (_guiHeight <= 0.0f)
		_guiHeight = ctx.widget->getHeight();

	float wX, wY, wZ;
	ctx.widget->getPosition(wX, wY, wZ);

	convertToXoreos(wX, wY, ctx.widget->getHeight());
	wZ = _widgetZ + wZ;

	ctx.widget->setPosition(wX, wY, wZ);

	_widgetZ -= 1.0f;

	addWidget(ctx.widget);

	// Go down to the children
	if (ctx.strct->hasField("CONTROLS")) {
		const Aurora::GFF3List &children = ctx.strct->getList("CONTROLS");

		for (Aurora::GFF3List::const_iterator c = children.begin(); c != children.end(); ++c)
			loadWidget(**c, ctx.widget);
	}
}
Пример #9
0
void GUI::load(const Common::UString &resref) {
	_name = resref;

	try {
		Common::ScopedPtr<Aurora::GFF3File>
			gff(new Aurora::GFF3File(resref, Aurora::kFileTypeGUI, MKTAG('G', 'U', 'I', ' '), true));

		loadWidget(gff->getTopLevel(), 0);

	} catch (Common::Exception &e) {
		e.add("Can't load GUI \"%s\"", resref.c_str());
		throw;
	}
}
Пример #10
0
void TocDock::fillInfo()
{
	if (!m_tree) // use delayed initialization for faster startup if not all docks are visible
		loadWidget();

    const QDomDocument *toc = document()->toc();
    if (toc) {
        fillToc(document(), *toc, m_tree, 0);
    } else {
        QTreeWidgetItem *item = new QTreeWidgetItem();
        item->setText(0, tr("No table of contents found."));
        item->setFlags(item->flags() & ~Qt::ItemIsEnabled);
        m_tree->addTopLevelItem(item);
    }
	delete toc;
}
Пример #11
0
    TGUI_API Widget::Ptr loadButton(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Button::Ptr button;
        if (widget)
            button = std::static_pointer_cast<Button>(widget);
        else
            button = std::make_shared<Button>();

        loadWidget(node, button);
        if (node->propertyValuePairs["text"])
            button->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["textsize"])
            button->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));

        return button;
    }
Пример #12
0
void GUI::load(const Common::UString &resref) {
	// This is only relevant to Jade Empire.
	// LTI prefixed GUI definitions for the Windows version of Jade Empire
	// with lti_ to support mouse and keyboard control.
	_name = ResMan.hasResource("lti_" + resref, Aurora::kFileTypeGUI) ? _name = "lti_" + resref : resref;

	try {
		_gff.reset(new Aurora::GFF3File(_name, Aurora::kFileTypeGUI, MKTAG('G', 'U', 'I', ' ')));

		loadWidget(_gff->getTopLevel(), 0);

	} catch (Common::Exception &e) {
		e.add("Can't load GUI \"%s\"", _name.c_str());
		throw;
	}
}
Пример #13
0
void Loader::load() {
    auto node = ResourceRegistry::get<XMLResource>(
            "data"
        )->doc().first_element_by_path(
            "/kriti/guis"
        );

    if(!node) {
        Message3(GUI, Debug, "No GUIs specified in data file!");
        return;
    }

    for(auto child : node) {
        std::string guiName = child.attribute("name").as_string("");
        m_guis[guiName] = loadWidget(child.child("widget"));
    }
}
Пример #14
0
    TGUI_API Widget::Ptr loadPicture(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Picture::Ptr picture;
        if (widget)
            picture = std::static_pointer_cast<Picture>(widget);
        else
            picture = std::make_shared<Picture>();

        if (node->propertyValuePairs["filename"])
            picture = std::make_shared<Picture>(DESERIALIZE_STRING("filename"));

        loadWidget(node, picture);

        if (node->propertyValuePairs["smooth"])
            picture->setSmooth(parseBoolean(node->propertyValuePairs["smooth"]->value));

        return picture;
    }
Пример #15
0
void GUI::load(const Common::UString &resref) {
	_name = resref;

	Aurora::GFF3File *gff = 0;
	try {
		gff = new Aurora::GFF3File(resref, Aurora::kFileTypeGUI, MKTAG('G', 'U', 'I', ' '));

		loadWidget(gff->getTopLevel(), 0);

	} catch (Common::Exception &e) {
		delete gff;

		e.add("Can't load GUI \"%s\"", resref.c_str());
		throw;
	}

	delete gff;
}
Пример #16
0
    TGUI_API Widget::Ptr loadSlider(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Slider::Ptr slider;
        if (widget)
            slider = std::static_pointer_cast<Slider>(widget);
        else
            slider = std::make_shared<Slider>();

        loadWidget(node, slider);
        if (node->propertyValuePairs["minimum"])
            slider->setMinimum(tgui::stoi(node->propertyValuePairs["minimum"]->value));
        if (node->propertyValuePairs["maximum"])
            slider->setMaximum(tgui::stoi(node->propertyValuePairs["maximum"]->value));
        if (node->propertyValuePairs["value"])
            slider->setValue(tgui::stoi(node->propertyValuePairs["value"]->value));

        return slider;
    }
Пример #17
0
void GUI::load(const Common::UString &resref, float width, float height) {
	_name = resref;

	Aurora::GFFFile *gff = 0;
	try {
		gff = new Aurora::GFFFile(resref, Aurora::kFileTypeGUI, MKID_BE('GUI '));

		loadWidget(gff->getTopLevel(), 0, width, height);

	} catch (Common::Exception &e) {
		delete gff;

		e.add("Can't load GUI \"%s\"", resref.c_str());
		throw;
	}

	delete gff;
}
Пример #18
0
    TGUI_API Widget::Ptr loadEditBox(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        EditBox::Ptr editBox;
        if (widget)
            editBox = std::static_pointer_cast<EditBox>(widget);
        else
            editBox = std::make_shared<EditBox>();

        loadWidget(node, editBox);

        if (node->propertyValuePairs["text"])
            editBox->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["defaulttext"])
            editBox->setDefaultText(DESERIALIZE_STRING("defaulttext"));
        if (node->propertyValuePairs["textsize"])
            editBox->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));
        if (node->propertyValuePairs["maximumcharacters"])
            editBox->setMaximumCharacters(tgui::stoi(node->propertyValuePairs["maximumcharacters"]->value));
        if (node->propertyValuePairs["textwidthlimited"])
            editBox->limitTextWidth(parseBoolean(node->propertyValuePairs["textwidthlimited"]->value));
        if (node->propertyValuePairs["caretwidth"])
            editBox->setCaretWidth(tgui::stof(node->propertyValuePairs["caretwidth"]->value));
        if (node->propertyValuePairs["numbersonly"])
            editBox->setNumbersOnly(parseBoolean(node->propertyValuePairs["numbersonly"]->value));
        if (node->propertyValuePairs["passwordcharacter"])
        {
            std::string pass = DESERIALIZE_STRING("passwordcharacter");
            if (!pass.empty())
                editBox->setPasswordCharacter(pass[0]);
        }
        if (node->propertyValuePairs["alignment"])
        {
            if (toLower(node->propertyValuePairs["alignment"]->value) == "left")
                editBox->setAlignment(EditBox::Alignment::Left);
            else if (toLower(node->propertyValuePairs["alignment"]->value) == "center")
                editBox->setAlignment(EditBox::Alignment::Center);
            else if (toLower(node->propertyValuePairs["alignment"]->value) == "right")
                editBox->setAlignment(EditBox::Alignment::Right);
            else
                throw Exception{"Failed to parse Alignment property. Only the values Left, Center and Right are correct."};
        }

        return editBox;
    }
Пример #19
0
    TGUI_API Widget::Ptr loadLabel(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Label::Ptr label;
        if (widget)
            label = std::static_pointer_cast<Label>(widget);
        else
            label = std::make_shared<Label>();

        loadWidget(node, label);

        if (node->propertyValuePairs["textstyle"])
        {
            sf::Uint32 style = sf::Text::Regular;
            std::vector<std::string> styles = tgui::split(node->propertyValuePairs["textstyle"]->value, '|');
            for (auto& elem : styles)
            {
                std::string requestedStyle = toLower(trim(elem));
                if (requestedStyle == "bold")
                    style |= sf::Text::Bold;
                else if (requestedStyle == "italic")
                    style |= sf::Text::Italic;
                else if (requestedStyle == "underlined")
                    style |= sf::Text::Underlined;
                else if (requestedStyle == "strikethrough")
                    style |= sf::Text::StrikeThrough;
                else if (requestedStyle != "regular")
                    throw Exception{"Failed to parse TextStyle property, found unknown style."};
            }

            label->setTextStyle(style);
        }

        if (node->propertyValuePairs["text"])
            label->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["textsize"])
            label->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));
        if (node->propertyValuePairs["maximumtextwidth"])
            label->setMaximumTextWidth(tgui::stof(node->propertyValuePairs["maximumtextwidth"]->value));
        if (node->propertyValuePairs["autosize"])
            label->setAutoSize(parseBoolean(node->propertyValuePairs["autosize"]->value));

        return label;
    }
Пример #20
0
    TGUI_API Widget::Ptr loadSpinButton(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        SpinButton::Ptr spinButton;
        if (widget)
            spinButton = std::static_pointer_cast<SpinButton>(widget);
        else
            spinButton = std::make_shared<SpinButton>();

        loadWidget(node, spinButton);
        if (node->propertyValuePairs["minimum"])
            spinButton->setMinimum(tgui::stoi(node->propertyValuePairs["minimum"]->value));
        if (node->propertyValuePairs["maximum"])
            spinButton->setMaximum(tgui::stoi(node->propertyValuePairs["maximum"]->value));
        if (node->propertyValuePairs["value"])
            spinButton->setValue(tgui::stoi(node->propertyValuePairs["value"]->value));
        if (node->propertyValuePairs["verticalscroll"])
            spinButton->setVerticalScroll(parseBoolean(node->propertyValuePairs["verticalscroll"]->value));

        return spinButton;
    }
Пример #21
0
    TGUI_API Widget::Ptr loadCheckBox(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        CheckBox::Ptr checkbox;
        if (widget)
            checkbox = std::static_pointer_cast<CheckBox>(widget);
        else
            checkbox = std::make_shared<CheckBox>();

        loadWidget(node, checkbox);
        if (node->propertyValuePairs["text"])
            checkbox->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["textsize"])
            checkbox->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));
        if (node->propertyValuePairs["checked"])
        {
            if (parseBoolean(node->propertyValuePairs["checked"]->value))
                checkbox->check();
        }

        return checkbox;
    }
Пример #22
0
    TGUI_API Widget::Ptr loadRadioButton(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        RadioButton::Ptr radioButton;
        if (widget)
            radioButton = std::static_pointer_cast<RadioButton>(widget);
        else
            radioButton = std::make_shared<RadioButton>();

        loadWidget(node, radioButton);
        if (node->propertyValuePairs["text"])
            radioButton->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["textsize"])
            radioButton->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));
        if (node->propertyValuePairs["checked"])
        {
            if (parseBoolean(node->propertyValuePairs["checked"]->value))
                radioButton->check();
        }

        return radioButton;
    }
Пример #23
0
    TGUI_API Widget::Ptr loadScrollbar(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Scrollbar::Ptr scrollbar;
        if (widget)
            scrollbar = std::static_pointer_cast<Scrollbar>(widget);
        else
            scrollbar = std::make_shared<Scrollbar>();

        loadWidget(node, scrollbar);
        if (node->propertyValuePairs["lowvalue"])
            scrollbar->setLowValue(tgui::stoi(node->propertyValuePairs["lowvalue"]->value));
        if (node->propertyValuePairs["maximum"])
            scrollbar->setMaximum(tgui::stoi(node->propertyValuePairs["maximum"]->value));
        if (node->propertyValuePairs["value"])
            scrollbar->setValue(tgui::stoi(node->propertyValuePairs["value"]->value));
        if (node->propertyValuePairs["arrowscrollamount"])
            scrollbar->setArrowScrollAmount(tgui::stoi(node->propertyValuePairs["arrowscrollamount"]->value));
        if (node->propertyValuePairs["autohide"])
            scrollbar->setAutoHide(parseBoolean(node->propertyValuePairs["autohide"]->value));

        return scrollbar;
    }
Пример #24
0
    TGUI_API Widget::Ptr loadComboBox(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        ComboBox::Ptr comboBox;
        if (widget)
            comboBox = std::static_pointer_cast<ComboBox>(widget);
        else
            comboBox = std::make_shared<ComboBox>();

        for (auto& childNode : node->children)
        {
            if (toLower(childNode->name) == "listbox")
                comboBox->setListBox(std::static_pointer_cast<ListBox>(WidgetLoader::getLoadFunction("listbox")(childNode)));
        }
        REMOVE_CHILD("listbox");

        loadWidget(node, comboBox);

        if (node->propertyValuePairs["itemstodisplay"])
            comboBox->setItemsToDisplay(tgui::stoi(node->propertyValuePairs["itemstodisplay"]->value));

        return comboBox;
    }
Пример #25
0
    TGUI_API Widget::Ptr loadProgressBar(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        ProgressBar::Ptr progressBar;
        if (widget)
            progressBar = std::static_pointer_cast<ProgressBar>(widget);
        else
            progressBar = std::make_shared<ProgressBar>();

        loadWidget(node, progressBar);
        if (node->propertyValuePairs["minimum"])
            progressBar->setMinimum(tgui::stoi(node->propertyValuePairs["minimum"]->value));
        if (node->propertyValuePairs["maximum"])
            progressBar->setMaximum(tgui::stoi(node->propertyValuePairs["maximum"]->value));
        if (node->propertyValuePairs["value"])
            progressBar->setValue(tgui::stoi(node->propertyValuePairs["value"]->value));
        if (node->propertyValuePairs["text"])
            progressBar->setText(DESERIALIZE_STRING("text"));
        if (node->propertyValuePairs["textsize"])
            progressBar->setTextSize(tgui::stoi(node->propertyValuePairs["textsize"]->value));

        if (node->propertyValuePairs["filldirection"])
        {
            std::string requestedStyle = toLower(trim(node->propertyValuePairs["filldirection"]->value));
            if (requestedStyle == "lefttoright")
                progressBar->setFillDirection(tgui::ProgressBar::FillDirection::LeftToRight);
            else if (requestedStyle == "righttoleft")
                progressBar->setFillDirection(tgui::ProgressBar::FillDirection::RightToLeft);
            else if (requestedStyle == "toptobottom")
                progressBar->setFillDirection(tgui::ProgressBar::FillDirection::TopToBottom);
            else if (requestedStyle == "toptobottom")
                progressBar->setFillDirection(tgui::ProgressBar::FillDirection::TopToBottom);
            else
                throw Exception{"Failed to parse FillDirection property, found unknown value."};
        }

        return progressBar;
    }
Пример #26
0
    TGUI_API Widget::Ptr loadKnob(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        Knob::Ptr knob;
        if (widget)
            knob = std::static_pointer_cast<Knob>(widget);
        else
            knob = std::make_shared<Knob>();

        loadWidget(node, knob);
        if (node->propertyValuePairs["startrotation"])
            knob->setStartRotation(tgui::stof(node->propertyValuePairs["startrotation"]->value));
        if (node->propertyValuePairs["endrotation"])
            knob->setEndRotation(tgui::stof(node->propertyValuePairs["endrotation"]->value));
        if (node->propertyValuePairs["minimum"])
            knob->setMinimum(tgui::stoi(node->propertyValuePairs["minimum"]->value));
        if (node->propertyValuePairs["maximum"])
            knob->setMaximum(tgui::stoi(node->propertyValuePairs["maximum"]->value));
        if (node->propertyValuePairs["value"])
            knob->setValue(tgui::stoi(node->propertyValuePairs["value"]->value));
        if (node->propertyValuePairs["clockwiseturning"])
            knob->setClockwiseTurning(parseBoolean(node->propertyValuePairs["clockwiseturning"]->value));

        return knob;
    }
Пример #27
0
void GUI::loadWidget(const Aurora::GFF3Struct &strct, Widget *parent) {
	WidgetContext ctx(strct, parent);

	createWidget(ctx);

	addWidget(ctx.widget);

	if (ctx.parent) {
		if (ctx.strct->getString("Obj_Parent") != ctx.parent->getTag())
			throw Common::Exception("Parent's tag != Obj_Parent");

		parent->addChild(*ctx.widget);

		float pX, pY, pZ;
		parent->getPosition(pX, pY, pZ);

		float x = ctx.strct->getDouble("Obj_X") * 100.0 + pX;
		float y = ctx.strct->getDouble("Obj_Y") * 100.0 + pY;
		float z = pZ - ctx.strct->getDouble("Obj_Z") * 100.0;

		ctx.widget->setPosition(x, y, z);
	} else {
		// We'll ignore these for now, centering the GUI
	}

	initWidget(ctx);

	// Create a caption/label and move the label to its destined position
	WidgetLabel *label = createCaption(ctx);
	if (label && ctx.strct->hasField("Obj_Caption")) {
		const Aurora::GFF3Struct &caption = ctx.strct->getStruct("Obj_Caption");

		float alignH = caption.getDouble("AurString_AlignH");
		float alignV = caption.getDouble("AurString_AlignV");

		float labelX = ctx.strct->getDouble("Obj_Label_X") * 100.0;
		float labelY = ctx.strct->getDouble("Obj_Label_Y") * 100.0;
		float labelZ = ctx.strct->getDouble("Obj_Label_Z") * 100.0;

		if (ctx.type != kWidgetTypeLabel) {
			if (label->getWidth() > ctx.widget->getWidth() || label->getHeight() > ctx.widget->getHeight())
				label->setText(label->getText(), alignH, ctx.widget->getWidth(), ctx.widget->getHeight());

			labelX += ctx.widget->getWidth () * alignV;
			labelY += ctx.widget->getHeight() * alignH;

			labelX -= label->getWidth () / 2;
			labelY -= label->getHeight() / 2;
		} else {
			float labelWidth = 0.0;
			if (ctx.strct->hasField("Obj_Label_Width"))
				labelWidth = ctx.strct->getDouble("Obj_Label_Width") * 100.0;

			float labelHeight = 0.0;
			if (ctx.strct->hasField("Obj_Label_Height"))
				labelHeight = ctx.strct->getDouble("Obj_Label_Height") * 100.0;

			if (alignV == 0.5) {
				bool multilines = false;
				if (label->getWidth() > labelWidth)
					multilines = true;

				label->setText(label->getText(), alignH, labelWidth, labelHeight);
				labelX += labelWidth * alignH;

				if (multilines)
					labelY += label->getHeight() * alignV;
			}

			labelX -= label->getWidth () * alignH;

			labelY -= label->getHeight();
			labelY -= label->getHeight() * alignV;
		}

		label->movePosition(labelX, labelY, -labelZ);
	}

	// uint32 layer = strct.getUint("Obj_Layer");
	// bool locked = strct.getUint("Obj_Locked") != 0;

	// Go down to the children
	if (ctx.strct->hasField("Obj_ChildList")) {
		const Aurora::GFF3List &children = ctx.strct->getList("Obj_ChildList");

		for (Aurora::GFF3List::const_iterator c = children.begin(); c != children.end(); ++c)
			loadWidget(**c, ctx.widget);
	}
}
Пример #28
0
bool CQUpdatesWidget::enterProtected()
{
  loadWidget();

  return true;
}
Пример #29
0
void MainWindow::showUI()
{
    infoloader->run();

//    ui->webView->setHtml(html,QUrl("qrc:/"));

    QTextStream sout(stdout);
    sout << infoloader->resultAsText();

    ui->progressBar->setVisible(false);
    bool qmlUI = false;

    // If QtDeclarative and Qt Quick Components are available, use QML UI
    QWidget* widget = NULL;
    if (infoloader->isLoaded("Qt5Quick") || infoloader->isLoaded("QtQuick")) { // go for fancy declarative UI instead of QWidgets
        sout << "QtQuick module present, contemplating QML UI";
        qDebug() << "QtQuick module present, contemplating QML UI";
        if (callBoolFunction("qt5declarativeui", "isQmlUiAvailable")) {
            sout << "loading QML5 UI";
            qDebug() << "loading QML5 UI";
            widget = loadWidget("qt5declarativeui", "declarativeUI");
            sout << widget;
            qDebug() << widget;
        }
    }
    if (widget == NULL && (infoloader->isLoaded("QtDeclarative") || infoloader->isLoaded("Qt5Declarative"))) { // go for fancy declarative UI instead of QWidgets
        sout << "Declarative module present, contemplating QML UI";

        if (widget == NULL && callBoolFunction("declarativeui", "isQmlUiAvailable")) {
            sout << "loading QML UI";
            widget = loadWidget("declarativeui", "declarativeUI");
        }
    }
    if (widget != NULL) { // we have a living breathing QtQuick widget!
        sout << "QML UI is a GO!";
        qDebug() << "QML UI is a GO!";
        qmlUI = true;
        widget->setParent(this);
        ui->textBrowser->setVisible(false);
        ui->widget->setEnabled(true);
        ui->widget->setVisible(true);
        widget->showFullScreen();
        // Note that QML buttons should call the same methods as the auto-slot-connected buttons
    } else {
//        this->statusBar()->setVisible(true);
        ui->emailButton->setVisible(true);
        ui->jsbinButton->setVisible(true);
        ui->clipboardButton->setVisible(true);
        ui->saveButton->setVisible(true);
#ifndef Q_WS_MAEMO_5
        ui->closeButton->setVisible(true); // maemo5 has X provided by the window manager
#endif
    }

    if (!qmlUI) {
        ui->textBrowser->setHtml(infoloader->resultAsHTML());
    } else {
        delete ui->textBrowser;
        ui->textBrowser = 0;
    }
}
Пример #30
0
    TGUI_API Widget::Ptr loadListBox(std::shared_ptr<DataIO::Node> node, Widget::Ptr widget = nullptr)
    {
        ListBox::Ptr listBox;
        if (widget)
            listBox = std::static_pointer_cast<ListBox>(widget);
        else
            listBox = std::make_shared<ListBox>();

        loadWidget(node, listBox);

        if (node->propertyValuePairs["items"])
        {
            if (!node->propertyValuePairs["items"]->listNode)
                throw Exception{"Failed to parse 'Items' property, expected a list as value"};

            if (node->propertyValuePairs["itemids"])
            {
                if (!node->propertyValuePairs["itemids"]->listNode)
                    throw Exception{"Failed to parse 'ItemIds' property, expected a list as value"};

                if (node->propertyValuePairs["items"]->valueList.size() != node->propertyValuePairs["itemids"]->valueList.size())
                    throw Exception{"Amounts of values for 'Items' differs from the amount in 'ItemIds'"};

                for (unsigned int i = 0; i < node->propertyValuePairs["items"]->valueList.size(); ++i)
                {
                    listBox->addItem(Deserializer::deserialize(ObjectConverter::Type::String, node->propertyValuePairs["items"]->valueList[i]).getString(),
                                     Deserializer::deserialize(ObjectConverter::Type::String, node->propertyValuePairs["itemids"]->valueList[i]).getString());
                }
            }
            else // There are no item ids
            {
                for (auto& item : node->propertyValuePairs["items"]->valueList)
                    listBox->addItem(item);
            }
        }
        else // If there are no items, there should be no item ids
        {
            if (node->propertyValuePairs["itemids"])
            {
                if (!node->propertyValuePairs["itemids"]->listNode)
                    throw Exception{"Failed to parse 'ItemIds' property, expected a list as value"};

                if (!node->propertyValuePairs["itemids"]->valueList.empty())
                    throw Exception{"Found 'ItemIds' property while there is no 'Items' property"};
            }
        }

        if (node->propertyValuePairs["itemheight"])
            listBox->setItemHeight(tgui::stoi(node->propertyValuePairs["itemheight"]->value));
        if (node->propertyValuePairs["maximumitems"])
            listBox->setMaximumItems(tgui::stoi(node->propertyValuePairs["maximumitems"]->value));

        for (auto& childNode : node->children)
        {
            if (toLower(childNode->name) == "scrollbar")
                listBox->setScrollbar(std::static_pointer_cast<Scrollbar>(WidgetLoader::getLoadFunction("scrollbar")(childNode)));
        }
        REMOVE_CHILD("scrollbar");

        return listBox;
    }