KRpmPlugin::KRpmPlugin(QObject *parent,
const QStringList &args)
: KFilePlugin(parent, args)
{
KFileMimeTypeInfo* info = addMimeTypeInfo( "application/x-rpm" );
KFileMimeTypeInfo::GroupInfo* group = 0L;
group = addGroupInfo(info, "General", i18n("General"));
KFileMimeTypeInfo::ItemInfo* item;
item = addItemInfo(group, "Name", i18n("Name"), QVariant::String);
item = addItemInfo(group, "Version", i18n("Version"), QVariant::String);
item = addItemInfo(group, "Release", i18n("Release"), QVariant::Int);
item = addItemInfo(group, "Summary", i18n("Summary"), QVariant::String);
setAttributes ( item, KFileMimeTypeInfo::Description );
item = addItemInfo(group, "Group", i18n("Group"), QVariant::String);
item = addItemInfo(group, "Size", i18n("Size"), QVariant::Int);
setUnit ( item, KFileMimeTypeInfo::Bytes );
item = addItemInfo(group, "Vendor", i18n("Vendor"), QVariant::String );
item = addItemInfo(group, "Packager", i18n("Packager"), QVariant::String );
item = addItemInfo(group, "Archive Offset", i18n("Archive Offset"), QVariant::Int);
item = addItemInfo(group, "Comment", i18n("Comment"), QVariant::String);
setAttributes( item, KFileMimeTypeInfo::MultiLine );
group = addGroupInfo(info, "All tags", i18n("All tags"));
addVariableInfo(group, QVariant::String, 0);
}
SkeletalCreature::SkeletalCreature(unsigned char _family) : Agent(_family, 0, 0, 0) {
facialexpression = 0;
pregnancy = 0;
eyesclosed = false;
// TODO: set zorder randomly :) should be somewhere between 1000-2700, at a /guess/
zorder = 1500;
ticks = 0;
gaitgene = 0;
calculated = false;
if (engine.version == 1) {
setAttributes(64 + 4 + 2); // mouseable, activateable, groundbound(?!)
} else if (engine.version == 2) {
setAttributes(128 + 64 + 4 + 2); // mouseable, activateable, suffersphysics, sufferscollisions
// default values from original engine
size.setInt(224);
rest.setInt(70);
accg.setInt(15);
aero.setInt(10);
}
for (unsigned int i = 0; i < 6; i++) appearancegenes[i] = 0;
skeleton = new SkeletonPart(this);
}
void KOfficePlugin::makeMimeTypeInfo(const QString& mimeType)
{
KFileMimeTypeInfo* info = addMimeTypeInfo( mimeType );
userdefined = addGroupInfo(info, UserDefined, i18n("User Defined"));
addVariableInfo(userdefined, QVariant::String,
KFileMimeTypeInfo::Addable |
KFileMimeTypeInfo::Removable |
KFileMimeTypeInfo::Modifiable);
KFileMimeTypeInfo::GroupInfo* group = 0L;
group = addGroupInfo(info, DocumentInfo, i18n("Document Information"));
KFileMimeTypeInfo::ItemInfo* item;
int i = 0;
for (i = 0; Information[i]; i+=2){
item = addItemInfo(group, Information[i], i18n(Information[i+1]),
QVariant::String);
setAttributes(item, KFileMimeTypeInfo::Modifiable);
switch (i){
case 0:
setHint(item, KFileMimeTypeInfo::Name);
break;
case 1:
setHint(item, KFileMimeTypeInfo::Author);
break;
case 2:
setHint(item, KFileMimeTypeInfo::Description);
default:;
}
}
item = addItemInfo(group, metakeyword, i18n("Keywords"),
QVariant::String);
setHint(item, KFileMimeTypeInfo::Description);
setAttributes(item, KFileMimeTypeInfo::Modifiable);
group = addGroupInfo(info, DocAdvanced, i18n("Document Advanced"));
for (i = 0; Advanced[i]; i+=2){
// I should add the isDate property instead of testing the index, but it works well, who cares ? :-)
QVariant::Type typ = QVariant::String;
if (i > 1 && i < 8)
typ = QVariant::DateTime;
if (i == 14)
typ = QVariant::String;
item = addItemInfo(group, Advanced[i], i18n(Advanced[i+1]), typ);
setHint(item, KFileMimeTypeInfo::Description);
}
group = addGroupInfo(info, DocStatistics, i18n("Document Statistics"));
for (i = 0; Statistics[i]; i+=2){
item = addItemInfo(group, Statistics[i], i18n(Statistics[i+1]),
QVariant::Int);
setHint(item, KFileMimeTypeInfo::Length);
}
}
void MidiControllableParameter::setPreferred(bool on)
{
if (on)
{
setAttributes(attributes() | MidiControllableParameter::Preferred);
}
else
{
setAttributes(attributes() & ~MidiControllableParameter::Attributes(MidiControllableParameter::Preferred));
}
}
void LoadDefaultsDecoder::setAttributes(Root &obj, //Root &obj_inst,
const Element& melem,
std::set<std::string> used_attributes)
{
MapType::const_iterator I;
for (I = melem.asMap().begin(); I != melem.asMap().end(); I++) {
std::set<std::string>::const_iterator attr_found =
used_attributes.find(I->first);
if (attr_found == used_attributes.end()) {
//cout<<" -->"<<I->first<<endl;
obj->setAttr(I->first, I->second);
//obj_inst->setAttr(I->first, I->second);
}
used_attributes.insert(I->first);
}
I = melem.asMap().find(Atlas::Objects::PARENTS_ATTR);
if (I != melem.asMap().end()) {
for (ListType::const_iterator J = I->second.asList().begin();
J != I->second.asList().end(); J++) {
//cout<<" >"<<J->asString()<<endl;
const Element & parent_melem = getMessageElement(J->asString());
setAttributes(obj, /*obj_inst,*/ parent_melem, used_attributes);
}
}
}
void Kit::ingestCsvInput(std::vector<std::vector<std::string>> csvFieldList)
{
std::vector<std::string> csvField;
std::string firstField;
std::string quantity;
std::string partNumber;
std::string description;
int line;
for (int i = 0; i < csvFieldList.size(); i++)
{
line = i;
csvField = csvFieldList[i];
if (line == 0)
{
firstField = csvField[0];
setKitName(firstField);
}
//checks if field is size 3 and if not header
if (csvField.size() >= 3 && csvField[0] != "Qty")
{
quantity = csvField[0];
partNumber = csvField[1];
description = csvField[2];
setQuantity(quantity);
setPartNumber(partNumber);
setDescription(description);
setAttributes(getQuantity(), getDescription());
addParts();
}
}
}//end ingestCsvInput()
bool PP_Revision::_handleNestedRevAttr()
{
const gchar * pNestedRev = NULL;
getAttribute("revision", pNestedRev);
if(pNestedRev)
{
PP_RevisionAttr NestedAttr(pNestedRev);
// now remove "revision"
setAttribute("revision", NULL);
prune();
// overlay the attrs and props from the revision attribute
for(UT_uint32 i = 0; i < NestedAttr.getRevisionsCount(); ++i)
{
const PP_Revision * pRev = NestedAttr.getNthRevision(i);
UT_return_val_if_fail( pRev, false );
// ignore inserts and deletes
if(pRev->getType() == PP_REVISION_ADDITION || pRev->getType() == PP_REVISION_DELETION)
continue;
setProperties(pRev->getProperties());
setAttributes(pRev->getAttributes());
}
prune();
}
return true;
}
OSItem::OSItem(const OSItemId& itemId, OSItemType osItemType, QWidget * parent)
: QWidget(parent),
m_itemId(itemId),
m_selectionWidget(nullptr),
m_borderWidget(nullptr),
m_removeButton(nullptr),
m_textLbl(nullptr),
m_imageLeftLbl(nullptr),
m_imageRightLbl(nullptr),
m_mouseDown(false),
m_selected(false),
m_draggable(true),
m_inspectable(false),
m_acceptsDrops(false),
m_size(QSize()),
m_osItemType(osItemType),
m_borderColor(QColor(Qt::black)),
m_useLargeIcon(false)
{
this->setObjectName("OSItem");
createLayout();
setAttributes(osItemType);
}
PassRefPtr<HTMLElement> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
{
Document& document = ownerDocumentForCurrentNode();
RefPtr<HTMLElement> element = HTMLElementFactory::createHTMLElement(token->name(), document, true);
setAttributes(element.get(), token);
return element.release();
}
PassRefPtr<Element> HTMLConstructionSite::createElement(AtomicHTMLToken* token, const AtomicString& namespaceURI)
{
QualifiedName tagName(token->name());
RefPtr<Element> element = ownerDocumentForCurrentNode().createElement(tagName, true);
setAttributes(element.get(), token);
return element.release();
}
void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken* token)
{
RefPtr<HTMLScriptElement> element = HTMLScriptElement::create(ownerDocumentForCurrentNode());
setAttributes(element.get(), token);
attachLater(currentNode(), element);
m_openElements.push(element.release());
}
void NTNDArrayRecord::update()
{
lock();
try
{
beginGroupPut();
PVUByteArray::svector bytes;
imageGen->fillSharedVector(bytes,angle);
setValue(freeze(bytes));
if (firstTime)
{
int dims[] = { imageGen->getWidth(), imageGen->getHeight() };
setDimension(dims, 2);
setAttributes();
setSizes(static_cast<int64_t>(imageGen->getSize()));
firstTime = false;
}
setDataTimeStamp();
setUniqueId(count++);
process();
endGroupPut();
}
catch(...)
{
unlock();
throw;
}
angle += 1;
unlock();
}
bool CNSprite::initWithDictionary(CCDictionary * pDict)
{
if (!init())
{
CNLog("error");
return false;
}
if (!pDict)
{
CNLog("invalid parameter: pDict");
return false;
}
CCString * pFilename = (CCString *)pDict->objectForKey("File");
if (pFilename)
{
replaceImageWithFile(pFilename->getCString());
}
CCString * pOpacity = (CCString *)pDict->objectForKey("Opacity");
if (pOpacity)
{
setOpacity(pOpacity->intValue());
}
return setAttributes(pDict);
}
int HDMIDisplay::configure() {
if(!openFrameBuffer()) {
ALOGE("%s: Failed to open FB: %d", __FUNCTION__, mFbNum);
return -1;
}
readCEUnderscanInfo();
readResolution();
// TODO: Move this to activate
/* Used for changing the resolution
* getUserMode will get the preferred
* mode set thru adb shell */
mCurrentMode = getUserMode();
if (mCurrentMode == -1) {
//Get the best mode and set
mCurrentMode = getBestMode();
}
setAttributes();
// set system property
property_set("hw.hdmiON", "1");
// Read the system property to determine if downscale feature is enabled.
char value[PROPERTY_VALUE_MAX];
mMDPDownscaleEnabled = false;
if(property_get("sys.hwc.mdp_downscale_enabled", value, "false")
&& !strcmp(value, "true")) {
mMDPDownscaleEnabled = true;
}
return 0;
}
KRgbPlugin::KRgbPlugin(QObject *parent, const QStringList &args) :
KFilePlugin(parent, args)
{
KFileMimeTypeInfo* info = addMimeTypeInfo("image/x-rgb");
KFileMimeTypeInfo::GroupInfo* group = 0;
KFileMimeTypeInfo::ItemInfo* item;
group = addGroupInfo(info, "Comment", i18n("Comment"));
item = addItemInfo(group, "ImageName", i18n("Name"), QVariant::String);
setAttributes(item, KFileMimeTypeInfo::Modifiable);
setHint(item, KFileMimeTypeInfo::Description);
group = addGroupInfo(info, "Technical", i18n("Technical Details"));
item = addItemInfo(group, "Dimensions", i18n("Dimensions"), QVariant::Size);
setHint(item, KFileMimeTypeInfo::Size);
setUnit(item, KFileMimeTypeInfo::Pixels);
item = addItemInfo(group, "BitDepth", i18n("Bit Depth"), QVariant::Int);
setUnit(item, KFileMimeTypeInfo::BitsPerPixel);
item = addItemInfo(group, "ColorMode", i18n("Color Mode"), QVariant::String);
item = addItemInfo(group, "Compression", i18n("Compression"), QVariant::String);
item = addItemInfo(group, "SharedRows",
i18nc("percentage of avoided vertical redundancy (the higher the better)",
"Shared Rows"), QVariant::String);
}
bool TMedia::parse(QDomElement element)
{
root_element = element;
setAttributes(); // special for every media type
setBaseParameters(); // in this class
loaded = false;
return true;
}
void ObjectDepsRefsWidget::setAttributes(ModelWidget *model_wgt, BaseObject *object, BaseObject *parent_obj)
{
if(!model_wgt)
throw Exception(ERR_OPR_NOT_ALOC_OBJECT ,__PRETTY_FUNCTION__,__FILE__,__LINE__);
this->model_wgt=model_wgt;
setAttributes(model_wgt->getDatabaseModel(), object, parent_obj);
}
DynamicObjectData::DynamicObjectData(const char* pname,
ObjectData* r /* = NULL */) :
root(r ? r : this) {
if (pname) {
CountableHelper h(root);
parent = create_object(pname, Array(), false, root);
setAttributes(parent.get());
}
}
Kit::Kit()
{
setKitName("");
setPartNumber("");
setQuantity("");
setDescription("");
setAttributes("", "");
}//end Kit()
Node& Node::operator = ( const Node& other )
{
setName( other.name );
setAttributes( other.attributes );
setChildren( other.children );
flag = other.flag;
text = other.text;
return ( * this );
}
bool PackageUtils::preCreatePackage()
{
bool result = setAttributes() && prepareWidget() && writeDesktopFile() && writeInstallationScripts() && writeRemovalScripts();
#if defined(Q_OS_MAEMO6)
result = result && writeBackupConfigFile() && writeBackupRestoreScripts() && writeSecsessionFile();
#endif
return result;
}
void
AttributesEditor::noBoxEdited()
{
_boxEdited = NO_ID;
setAttributes(new AbstractBox);
_boxStartValue->clear();
_boxLengthValue->clear();
_boxName->clear();
_colorButtonPixmap->fill(Qt::gray);
}
void Control::refresh() {
updated = false;
HWND handle = getHandle();
if (handle == nullptr) {
handle = createHandle();
setHandle(handle);
}
setAttributes(handle);
}
void HairObject::setAttributes(HairObject *_oldObject){
if (_oldObject == NULL){
setAttributes();
} else {
setAttributes(
_oldObject->m_color,
_oldObject->m_numGroupHairs,
_oldObject->m_hairGroupSpread,
_oldObject->m_hairRadius,
_oldObject->m_noiseAmplitude,
_oldObject->m_noiseFrequency,
_oldObject->m_numSplineVertices,
_oldObject->m_shadowIntensity,
_oldObject->m_diffuseIntensity,
_oldObject->m_specularIntensity,
_oldObject->m_transparency,
_oldObject->m_useHairColorVariation,
_oldObject->m_hairColorVariation);
}
}
// ----------------------------------
XML::Node::Node(const char *fmt,...)
{
va_list ap;
va_start(ap, fmt);
char tmp[8192];
vsprintf(tmp,fmt,ap);
setAttributes(tmp);
va_end(ap);
init();
}
void Mesh::setVertices(vector<Vertex> vertices, vector<int> indices)
{
this->vertices.clear();
this->indices.clear();
this->vertices = vertices;
this->indices = indices;
setAttributes();
uploaded = false;
}
int VirtualDisplay::configure() {
if(!openFrameBuffer())
return -1;
if(ioctl(mFd, FBIOGET_VSCREENINFO, &mVInfo) < 0) {
ALOGD("%s: FBIOGET_VSCREENINFO failed with %s", __FUNCTION__,
strerror(errno));
return -1;
}
setAttributes();
return 0;
}
void GeneticGeneration::dump(TiXmlElement *generationElement,bool includeGenes)
{
setAttributes(generationElement);
for (int a=0;a<(int)individuals.size();a++)
{
TiXmlElement *individualElement = new TiXmlElement("Individual");
individuals[a]->dump(individualElement,includeGenes);
generationElement->LinkEndChild(individualElement);
}
}
void CPUSideTriangleMesh::generatePhongNormals()
{
assert( haveFaceNormals() && haveSmoothingGroups() && "Mesh should have smoothing groups - use generateSmoothingGroups");
// vertex normals
math::vector_of_vector3f normals(attributeArrays[0].count);
// vertex normals indices
std::vector<unsigned> indices(indicesArrays[0].indices.get(), indicesArrays[0].indices.get() + indicesArrays[0].count);
// vertex smoothing groups
std::vector<int> vertexSMGroup(attributeArrays[0].count, -1);
// average normals against faces sharing same smoothing group
for (size_t iFace = 0; iFace < faceNormals.size(); ++iFace)
{
for (size_t iVertInd = iFace * 3; iVertInd < iFace * 3 + 3; ++iVertInd)
{
unsigned iVert = indices[iVertInd];
if (vertexSMGroup[iVert] == -1)
{
vertexSMGroup[iVert] = get_first_nonzero_bit(smoothingGroups[iFace]);
normals[iVert] = faceNormals[iFace];
}
else if ( (smoothingGroups[iFace] != 0) && (smoothingGroups[iFace] & (1 << (vertexSMGroup[iVert] - 1))) ) {
normals[iVert] += faceNormals[iFace];
}
else
{
indices[iVertInd] = normals.size();
normals.push_back(faceNormals[iFace]);
vertexSMGroup.push_back( get_first_nonzero_bit(smoothingGroups[iFace]) );
}
}
}
// normalize all
for (size_t i = 0; i<normals.size(); ++i) {
normals[i] = math::normalize(normals[i]);
}
// find attribute slot for normals
int normalAttrIndex = getAttributeIndex("normal");
if (normalAttrIndex == -1) {
normalAttrIndex = getFreeAttributeIndex();
}
assert(normalAttrIndex != -1 && "No free slot for normals");
// setup normals
setAttributes("normal", normalAttrIndex, 3, normals.size(), sgl::FLOAT, &normals[0]);
setIndices(normalAttrIndex, indices.size(), &indices[0]);
}
void ScaleEngine::clone(const ScaleEngine *engine)
{
d_type = engine->type();
d_break_left = engine->axisBreakLeft();
d_break_right = engine->axisBreakRight();
d_break_pos = engine->breakPosition();
d_step_before = engine->stepBeforeBreak();
d_step_after = engine->stepAfterBreak();
d_minor_ticks_before = engine->minTicksBeforeBreak();
d_minor_ticks_after = engine->minTicksAfterBreak();
d_log10_scale_after = engine->log10ScaleAfterBreak();
d_break_width = engine->breakWidth();
d_break_decoration = engine->hasBreakDecoration();
setAttributes(engine->attributes());
setMargins(engine->loMargin(), engine->hiMargin());
}
