//--------------------------------------------------------------
void ofShader::checkShaderInfoLog(GLuint shader, GLenum type, ofLogLevel logLevel) {
GLsizei infoLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLength);
if (infoLength > 1) {
GLchar* infoBuffer = new GLchar[infoLength];
glGetShaderInfoLog(shader, infoLength, &infoLength, infoBuffer);
ofLog(logLevel, "ofShader: %s shader reports:\n%s", nameForType(type).c_str(), infoBuffer);
if (shaderSource.find(type) != shaderSource.end()) {
// The following regexp should match shader compiler error messages by Nvidia and ATI.
// Unfortunately, each vendor's driver formats error messages slightly different.
std::regex nvidia_ati("^.*[(:]{1}(\\d+)[:)]{1}.*");
std::regex intel("^[0-9]+:([0-9]+)\\([0-9]+\\):.*$");
std::smatch matches;
string infoString = (infoBuffer != nullptr) ? ofTrim(infoBuffer): "";
if (std::regex_search(infoString, matches, intel) || std::regex_search(infoString, matches, nvidia_ati)){
ofBuffer buf = shaderSource[type];
ofBuffer::Line line = buf.getLines().begin();
int offendingLineNumber = ofToInt(matches[1]);
ostringstream msg;
msg << "ofShader: " + nameForType(type) + ", offending line " << offendingLineNumber << " :"<< endl;
for(int i=0; line != buf.getLines().end(); line++, i++ ){
string s = *line;
if ( i >= offendingLineNumber -3 && i < offendingLineNumber + 2 ){
msg << "\t" << setw(5) << (i+1) << "\t" << s << endl;
}
}
ofLog(logLevel) << msg.str();
}else{
ofLog(logLevel) << shaderSource[type];
}
}
delete [] infoBuffer;
}
}
void ofPackageManager::addPackageToAddonsMakeFile(ofPackage package)
{
ofFile addonConfigFile(getAbsolutePath("addons.make"), ofFile::ReadOnly);
if (!addonConfigFile.exists())
{
addonConfigFile.create();
}
auto stringToAdd = package._path + " #" + package._url + "@" + package._checkout;
ofBuffer fileBuffer = addonConfigFile.readToBuffer();
std::string content;
auto foundPackage = false;
for (auto line : fileBuffer.getLines())
{
auto words = ofSplitString(ofTrim(line), "#");
// if path addon already listed in addon.make
// then update it
// else append a new line
if (ofTrim(words[0]) == package._path)
{
foundPackage = true;
content += stringToAdd;
content += "\n";
}
else
{
content += line + "\n";
}
// ofLogNotice() << content;
}
if (!foundPackage)
{
content += stringToAdd;
}
fileBuffer.set(content.c_str(), content.size());
addonConfigFile.close();
ofFile newAddonsMakeFile(getAbsolutePath("addons.make"), ofFile::ReadWrite);
if (newAddonsMakeFile.writeFromBuffer(fileBuffer))
{
ofLogNotice("ofPackageManager") << "successfully updated addons.make";
}
else
{
ofLogError("ofPackageManager") << "Could not update addons.make";
}
}
void update(){
char udpMessage[100000];
udp.Receive(udpMessage,100000);
string message=udpMessage;
if(message!="") {
vector<string> res = ofSplitString(message, ",");
mouse = ofVec2f(ofToInt(res[0]),ofToInt(res[1]));
if(ofTrim(res[1])=="click") {
click(1);
}else{
position(mouse);
}
}
}
void ofxDOMFlexBoxLayout::align(FlexDirection direction){
bool horizontal = direction == FlexDirection::ROW;
float paddingHorizontal = DOMLH::getPaddingHorizontal(_parent);
float paddingVertical = DOMLH::getPaddingVertical(_parent);
float wParent = ofGetWidth();
float hParent = ofGetHeight();
if(_parent->parent()){
wParent = _parent->getSizeByParent().x;
hParent = _parent->getSizeByParent().y;
}
float totalWidth = DOMLH::getDesiredWidthStretched(_parent, wParent) - paddingHorizontal;
float totalHeight = DOMLH::getDesiredHeightStretched(_parent, hParent) - paddingVertical;
// if(ofxGuiElement* el = dynamic_cast<ofxGuiElement*>(_parent)){
// cout << el->getName() << " total size: " << totalWidth << " " << totalHeight << endl;
// }
vector<vector<DOM::Element*>> lines;
vector<vector<DOM::Element*>> noFlexItems;
vector<vector<DOM::Element*>> flexItems;
vector<vector<float>> flexItemsBasis;
vector<float> totalSpaceMainAxis;
float mainAxisSize = horizontal ? totalWidth : totalHeight;
float crossAxisSize = horizontal ? totalHeight : totalWidth;
int linecount = 0;
if(children().size() > 0){
//newline
lines.push_back(vector<DOM::Element*>());
noFlexItems.push_back(vector<DOM::Element*>());
flexItems.push_back(vector<DOM::Element*>());
flexItemsBasis.push_back(vector<float>());
totalSpaceMainAxis.push_back(mainAxisSize);
}
//sort children according to flex attribute and main size of children
for(unsigned int i = 0; i < children().size(); i++){
DOM::Element* element = children().at(i);
float w, h;
if(horizontal){
w = DOMLH::getDesiredWidth(element, totalWidth);
h = DOMLH::getDesiredHeight(element, totalHeight);
}else{
w = DOMLH::getDesiredWidth(element, totalWidth);
h = DOMLH::getDesiredHeight(element, totalHeight);
}
float elementMainSize = horizontal ? w : h;
float elementCrossSize = horizontal ? h : w;
if(element){
if(elementFlexing(element)){
// element->setSizeByParent(totalWidth, totalHeight);
// set to minimal size on main axis
if(horizontal){
element->setSizeByParent(elementMainSize + DOMLH::getMarginHorizontal(element), elementCrossSize + DOMLH::getMarginVertical(element));
element->setLayoutSize(elementMainSize, elementCrossSize, true);
elementMainSize = element->getWidth() + DOMLH::getMarginHorizontal(element);
}else {
element->setSizeByParent(elementCrossSize + DOMLH::getMarginHorizontal(element), elementMainSize + DOMLH::getMarginVertical(element));
element->setLayoutSize(elementCrossSize, elementMainSize, true);
elementMainSize = element->getHeight() + DOMLH::getMarginVertical(element);
}
//if element is flexible, add it to the current line and save the items flex basis
if(element->hasAttribute("_flex")){
std::string flexval = element->getAttribute<std::string>("_flex");
if(flexval == "auto"){
lines.at(linecount).push_back(element);
flexItems.at(linecount).push_back(element);
flexItemsBasis.at(linecount).push_back(1);
continue;
}
if(isFloat(ofTrim(flexval))){
float intflexval = ofToFloat(flexval);
if(intflexval > 0){
lines.at(linecount).push_back(element);
flexItems.at(linecount).push_back(element);
flexItemsBasis.at(linecount).push_back(intflexval);
continue;
}
}
}
// not flexible or no valid flex attribute, not flexing on main axis
// add to new line if it does not fit and flex-wrap is on
if((int)totalSpaceMainAxis.at(linecount) - (int)elementMainSize < 0){
FlexWrap _wrap = getFlexWrap(_parent);
if(_wrap == FlexWrap::NOWRAP || i == 0){
//no new line
}else{
//new line
linecount++;
lines.push_back(vector<DOM::Element*>());
flexItems.push_back(vector<DOM::Element*>());
flexItemsBasis.push_back(vector<float>());
totalSpaceMainAxis.push_back(mainAxisSize);
}
}
lines.at(linecount).push_back(element);
totalSpaceMainAxis.at(linecount) -= elementMainSize;
}else {
//set an absolute positioned element to its desired independent size
if(DOMLH::elementAbsolutePositioned(element)){
element->setLayoutSize(w, h);
}
}
}
}
//set main size of flex items if they are flexible
for(unsigned int i = 0; i < flexItems.size(); i++){
int partscount = 0;
for(int parts : flexItemsBasis.at(i)){
partscount += parts;
}
if(partscount > 0){
float partsize = totalSpaceMainAxis.at(i)/partscount;
totalSpaceMainAxis.at(i) = 0;
for(unsigned int j = 0; j < flexItems.at(i).size(); j++){
DOM::Element* element = flexItems.at(i).at(j);
if(horizontal){
element->setSizeByParent(flexItemsBasis.at(i).at(j)*partsize, element->getSizeByParent().y);
setLayoutWidthMinusMargin(element, flexItemsBasis.at(i).at(j)*partsize);
}else{
element->setSizeByParent(element->getSizeByParent().x, flexItemsBasis.at(i).at(j)*partsize);
setLayoutHeightMinusMargin(element, flexItemsBasis.at(i).at(j)*partsize);
}
}
}
}
//set cross size of items if they stretch
AlignItems alignItems = getAlignItems(_parent);
vector<float> lineSizes;
float totalSpaceCrossAxis = crossAxisSize;
for(unsigned int i = 0; i < lines.size(); i++){
float lineSize = 0;
for(auto e : lines.at(i)){
float elementCrossSize = horizontal ?
e->getHeight()+DOMLH::getMarginVertical(e) :
e->getWidth()+DOMLH::getMarginHorizontal(e);
AlignSelf alignSelf = getAlignSelf(e);
if(((alignSelf != AlignSelf::AUTO) && (alignSelf != AlignSelf::STRETCH)) ||
((alignSelf == AlignSelf::AUTO) && (alignItems != AlignItems::STRETCH))){
if(elementCrossSize > lineSize){
lineSize = elementCrossSize;
}
}
}
totalSpaceCrossAxis -= lineSize;
lineSizes.push_back(lineSize);
}
// count how many lines do not have a fixed size
int zerolines = 0;
for(int lineSize : lineSizes){
if(lineSize == 0){
zerolines++;
}
}
// if there are lines without fixed height, take the remaining height of the parent
// and share it between the lines without fixed height
if(zerolines > 0){
for(unsigned int i = 0; i < lineSizes.size(); i++){
if(lineSizes[i] == 0){
lineSizes[i] = totalSpaceCrossAxis / zerolines;
}
}
totalSpaceCrossAxis = 0;
}
// check if lines are not big enough to fit in all elements minimal size
for(unsigned int i = 0; i < lines.size(); i++){
float lineSize = lineSizes.at(i);
for(auto e : lines.at(i)){
float elementCrossSize = horizontal ?
e->getHeight()+DOMLH::getMarginVertical(e) :
e->getWidth()+DOMLH::getMarginHorizontal(e);
if(elementCrossSize > lineSize){
lineSize = elementCrossSize;
}
}
lineSizes.at(i) = lineSize;
}
float newCrossAxisSize = 0;
for(int size : lineSizes){
newCrossAxisSize += size;
}
if(newCrossAxisSize > crossAxisSize){
totalSpaceCrossAxis = 0;
// if(horizontal){
// setHeightInLayoutAddPadding_parent, newCrossAxisSize);
// }else {
// setWidthInLayoutAddPadding(_parent, newCrossAxisSize);
// }
}
//take care of empty space on cross axis
int spacingCrossAxisStart = 0;
int spacingCrossAxisBetween = 0;
if(lines.size() > 1){
if(totalSpaceCrossAxis > 0){
switch(getAlignContent(_parent)){
case AlignContent::CENTER:
spacingCrossAxisStart = totalSpaceCrossAxis/2;
break;
case AlignContent::FLEX_END:
spacingCrossAxisStart = totalSpaceCrossAxis;
break;
case AlignContent::SPACE_AROUND:
spacingCrossAxisStart = totalSpaceCrossAxis/(lines.size()+1);
spacingCrossAxisBetween = spacingCrossAxisStart;
break;
case AlignContent::SPACE_BETWEEN:
spacingCrossAxisBetween = totalSpaceCrossAxis/(lines.size()-1);
break;
case AlignContent::STRETCH:
spacingCrossAxisBetween = totalSpaceCrossAxis/lines.size();
break;
default:break;
}
}
}else{
if(lines.size()>0){
lineSizes.at(0) = max(lineSizes.at(0),crossAxisSize);
}
}
totalWidth += paddingHorizontal;
totalHeight += paddingVertical;
float parentPaddingLeft = DOMLH::getPaddingLeft(_parent);
float parentPaddingTop = DOMLH::getPaddingTop(_parent);
float currentMainPos = 0;
float currentCrossPos = spacingCrossAxisStart;
currentCrossPos += horizontal ? parentPaddingTop : parentPaddingLeft;
for(unsigned int i = 0; i < lines.size(); i++){
//take care of empty space on main axis
int spacingMainAxisStart = horizontal ? parentPaddingLeft : parentPaddingTop;
int spacingMainAxisBetween = 0;
if(totalSpaceMainAxis.at(i) > 0){
switch(getJustifyContent(_parent)){
case JustifyContent::CENTER:
spacingMainAxisStart += totalSpaceMainAxis.at(i)/2;
break;
case JustifyContent::FLEX_END:
spacingMainAxisStart += totalSpaceMainAxis.at(i);
break;
case JustifyContent::SPACE_AROUND:
spacingMainAxisStart += totalSpaceMainAxis.at(i)/(lines.at(i).size()+1);
spacingMainAxisBetween = spacingMainAxisStart;
break;
case JustifyContent::SPACE_BETWEEN:
spacingMainAxisBetween = totalSpaceMainAxis.at(i)/(lines.at(i).size()-1);
break;
default:break;
}
}
currentMainPos = spacingMainAxisStart;
for(unsigned int j = 0; j < lines.at(i).size(); j++){
// set cross size of item
DOM::Element* element = lines.at(i).at(j);
AlignSelf alignSelf = getAlignSelf(element);
if(alignSelf == AlignSelf::STRETCH ||
((alignSelf == AlignSelf::AUTO) && (alignItems == AlignItems::STRETCH))){
if(horizontal){
element->setSizeByParent(element->getSizeByParent().x, lineSizes.at(i));
setLayoutHeightMinusMargin(element, lineSizes.at(i));
}else{
element->setSizeByParent(lineSizes.at(i), element->getSizeByParent().y);
setLayoutWidthMinusMargin(element, lineSizes.at(i));
}
}
//align item
float elementMainPos = currentMainPos;
float elementCrossPos = currentCrossPos;
float elementMainSize = horizontal ? getWidthPlusMargin(element) : getHeightPlusMargin(element);
float elementCrossSize = horizontal ? getHeightPlusMargin(element) : getWidthPlusMargin(element);
//align item on cross axis
AlignItems alignItem = alignItems;
if(alignSelf != AlignSelf::AUTO){
switch(alignSelf){
case AlignSelf::CENTER:
alignItem = AlignItems::CENTER;
break;
case AlignSelf::STRETCH:
case AlignSelf::FLEX_START:
alignItem = AlignItems::FLEX_START;
break;
case AlignSelf::FLEX_END:
alignItem = AlignItems::FLEX_END;
break;
default:
break;
}
}
switch(alignItem){
case AlignItems::FLEX_END:
elementCrossPos += lineSizes.at(i)-elementCrossSize;
break;
case AlignItems::CENTER:
elementCrossPos += (lineSizes.at(i)-elementCrossSize)/2.;
break;
default:
break;
}
//set final element position
if(horizontal){
DOMLH::setPosition(element, ofPoint(elementMainPos, elementCrossPos));
}else{
DOMLH::setPosition(element, ofPoint(elementCrossPos, elementMainPos));
}
totalWidth = max(totalWidth, element->getShape().getRight()+DOMLH::getMarginRight(element)+DOMLH::getPaddingRight(_parent));
totalHeight = max(totalHeight, element->getShape().getBottom()+DOMLH::getMarginBottom(element)+DOMLH::getPaddingBottom(_parent));
currentMainPos += elementMainSize + spacingMainAxisBetween;
}
currentCrossPos += lineSizes.at(i) + spacingCrossAxisBetween;
}
//make sure parent element contains all child elements on the main axis
// maxX += DOMLH::getPaddingRight(_parent);
// maxY += DOMLH::getPaddingBottom(_parent);
// if(horizontal){
// _parent->setLayoutSize(max(maxX,_parent->getWidth()), max(maxY,_parent->getHeight()));
// }else{
// _parent->setLayoutSize(max(maxX,_parent->getWidth()), max(maxY,_parent->getHeight()));
// }
// if(ofxGuiElement* el = dynamic_cast<ofxGuiElement*>(_parent)){
// cout << el->getName() << " total size end: " << totalWidth << " " << totalHeight << endl;
// }
_parent->setLayoutSize(totalWidth, totalHeight, false);
_parent->setNeedsRedraw();
}
void run(){
test_eq(ofTrimFront(" trim this string "),"trim this string ","trimfront");
test_eq(ofTrimBack(" trim this string ")," trim this string","trimback");
test_eq(ofTrim(" trim this string "),"trim this string","trim");
auto split0 = ofSplitString("hi this is a split test", " ");
test_eq(split0.size(),6u,"split size");
test_eq(split0[0],"hi","split 0");
test_eq(split0[1],"this","split 1");
test_eq(split0[2],"is","split 2");
test_eq(split0[3],"a","split 3");
test_eq(split0[4],"split","split 4");
test_eq(split0[5],"test","split 5");
auto split1 = ofSplitString(" hi this is a split test ", " ");
test_eq(split1.size(),8u,"split no trim size");
test_eq(split1[0],"","split no trim 0");
test_eq(split1[1],"hi","split no trim 1");
test_eq(split1[2],"this","split no trim 2");
test_eq(split1[3],"is","split no trim 3");
test_eq(split1[4],"a","split no trim 4");
test_eq(split1[5],"split","split no trim 5");
test_eq(split1[6],"test","split no trim 6");
test_eq(split1[7],"","split no trim 7");
auto split2 = ofSplitString(" hi this is a split test ", " ", true, true);
test_eq(split2.size(),6u,"split trim size");
test_eq(split2[0],"hi","split trim 0");
test_eq(split2[1],"this","split trim 1");
test_eq(split2[2],"is","split trim 2");
test_eq(split2[3],"a","split trim 3");
test_eq(split2[4],"split","split trim 4");
test_eq(split2[5],"test","split trim 5");
auto split3 = ofSplitString(" hi this is a split test ", " ", true, true);
test_eq(split2.size(),6u,"split trim2 size");
test_eq(split2[0],"hi","split trim2 0");
test_eq(split2[1],"this","split trim2 1");
test_eq(split2[2],"is","split trim2 2");
test_eq(split2[3],"a","split trim2 3");
test_eq(split2[4],"split","split trim2 4");
test_eq(split2[5],"test","split trim2 5");
test_eq(ofJoinString({"hi","this","is","a","join","test"}," "),"hi this is a join test","join string");
test_eq(ofJoinString({"hi"}," "),"hi","join string 1 element");
test_eq(ofJoinString({}," "),"","join string 0 elements");
std::string replace = "hi this is a replace test";
ofStringReplace(replace,"replace","replaceeee");
test_eq(replace , "hi this is a replaceeee test","replace string element");
test_eq(ofToLower("AbCéÉBbCcc"),"abcéébbccc","tolower");
test_eq(ofToUpper("AbCéÉBbCcc"),"ABCÉÉBBCCC","toupper");
// test #4363
std::vector<string> strs;
strs.push_back("hi");
strs.push_back("this");
strs.push_back("is");
strs.push_back("a");
strs.push_back("join");
strs.push_back("test");
test_eq(ofJoinString(strs,","),"hi,this,is,a,join,test","test #4363");
}
