path: root/menuApp/src/ofApp.cpp

#include "ofApp.h"

#define timtoken "3281768761.3dfcaf5.14ca9410c2aa4c00b9b60f36cd09d01a"
#define hangdaitoken "3939854844.b31608d.a61a4e49a4dc40a688c22f4e0e81da3a"

std::string replaceStrChar(std::string str, const std::string& replace, char ch) {

  // set our locator equal to the first appearance of any character in replace
  size_t found = str.find_first_of(replace);

  while (found != std::string::npos) { // While our position in the sting is in range.
    str[found] = ch; // Change the character at position.
    found = str.find_first_of(replace, found+1); // Relocate again.
  }

  return str; // return our new string.
}

bool ofApp::loadInstagramFeed(){

/*
	std::string test[5];
	int testindex=0;
	for (int i=0;i<255;i++){
		test[testindex]=" "+test[testindex];
		test[testindex][0]=i;
		if (i==25||i==126||i==174||i==229) test[testindex]="\n"+test[testindex];
		if (i==51||i==102||i==153||i==204) testindex++;
	}
*/
	items.clear();
    //items.resize(IMAGE_SLOTS);
    instagram.getUserRecentMedia("self",100);
    //instagram.getUserLikedMedia(12);

    ofLog(OF_LOG_NOTICE) << "instagram self feed -------------------> " << instagram.getImageURL().size() << " items ";
    //leave in verbose logging as ofxInstagram does anyway

    int slot=0;

    map<std::string,menuItem> newmenu;

    bool newInteresting=false;
    
    if (!instagram.getImageURL().empty())
    {
        for ( int i = 0; i < instagram.getImageURL().size(); i++)
        {
        	std::string str=replaceStrChar(instagram.getImageCaption()[i],"\n",' ');

        	vector <std::string> tokens = ofSplitString(str," ",true,true); //,ignoreEmpty=false,trim=false);

            std::string caption;
            std::string price;
            std::string tags;

            bool interesting=false;
            bool foundTags=false;
            bool foundPrice=false;

            for(auto it = tokens.begin(); it != tokens.end(); it++){
			    if((*it).at(0)=='#'){
			    	if (!foundPrice){
			    		price="";
			    		foundPrice=true;
			    	}
			    	if (*it==menutag){
			    		interesting=true;
			    	}
			    	tags+=*it;
			    	tags+=" ";
			    	foundTags=true;
			    }
			    else if(((uint8_t)(*it).at(0))==226){
					price=*it;
			    	foundPrice=true;
			    	price[0]=36; //replace with dollar to use hacked truetype font
			    	ofLog(OF_LOG_NOTICE) << "price is "<<price<<" from "<<*it;
			    }
			    else{
			    	if (!foundTags){
			    		caption+=*it;
			    		caption+=" ";
			    	}
			    }
			}

			if (interesting){

				items.push_back(menuItem(caption,price));
				//items[slot]=menuItem(test[i],price);

				std::string id=instagram.getImageID()[i];

				if (imagepool.find(id)==imagepool.end()){
					imagepool[id]=ofImage();
	
					//ofLog(OF_LOG_NOTICE) << menutag << " " << slot << " " << caption << price << " " << id;
					newInteresting=true;
				}
				
				if (!imagepool[id].isAllocated()) {
					getImages.loadFromURL(imagepool[id], instagram.getImageURL()[i]);
					ofLog(OF_LOG_NOTICE) << "LOADING " << id << " " << slot << " " << caption;
				}
				else {
					ofLog(OF_LOG_NOTICE) << "REUSE " << id << " " << slot << " " << menutag;
				}

				items[slot].image=&imagepool[id];

	            slot++;

	            if (slot==IMAGE_SLOTS) break;
			}
			else ofLog(OF_LOG_NOTICE) << "instagram " << i << " " << price << " " << tags;

//this is where we would clean up unused images in the pool

        }
    }
    lastPoll=ofGetElapsedTimef();

    if (newInteresting){
    	isGrabbed=false;
    }
    
    return newInteresting;
}

//--------------------------------------------------------------
void ofApp::setup(){

	scanner=dirScanner(ofFilePath().getUserHomeDir()+"/Dropbox/menugrab");

	scanner.scan();

	player=dirPlayer(&scanner);

/*
	std::string str ("€");

	ofLog(OF_LOG_NOTICE) << "code for € is " << ((int)str.at(0)) << " not " << 0xA4;
	ofLog(OF_LOG_NOTICE) << "-30 as uint8_t is " << ((int)((uint8_t)-30));
*/
	//items.resize(IMAGE_SLOTS);

	ofTrueTypeFont::setGlobalDpi(150);

	myText.init("American Typewriter Regular.ttf", FONTSIZE*FACTOR, 'i');

	background.load("images/background1080.png");
	overlay.load("images/overlay1080.png");

	//instagram.setup(hangdaitoken,"self");
    //instagram.setCertFileLocation(ofToDataPath("ca-bundle.crt",false));

    menutag=MENUTAG;

    //loadInstagramFeed();

/*
    instagram.getUserRecentMedia("self");
    //instagram.searchForTags("hangdai");

    //ofLog(OF_LOG_NOTICE) << instagram["data"][0]["caption"]["text"].asString();

    const Json::Value selfdata = instagram.getJSON()["data"];
	for ( int index = 0; index < selfdata.size(); ++index )  // Iterates over the sequence elements.
   		ofLog(OF_LOG_NOTICE) << selfdata[index]["caption"]["text"].asString();
*/
   	
    //load 
    ofSetFrameRate(15);

    lastPoll=POLL_INTERVAL;

    primed=false;
}

//--------------------------------------------------------------
void ofApp::update(){
	//ofBackground(255);	
}


//--------------------------------------------------------------
void ofApp::draw(){	
	ofSetColor(255,255,255);

	ofPushMatrix();	

		if(ROTATION>0){
			ofTranslate(1920*FACTOR,0*FACTOR);
			ofRotate(ROTATION);
			//ofTranslate(0*FACTOR,0*FACTOR);
		}

		player.draw();
		return;

		if (!player.draw()){

			if(ofGetElapsedTimef()-lastPoll>POLL_INTERVAL) {
				loadInstagramFeed();
			}

		
			
			ofPushMatrix(); //Store the coordinate system nexessary for some reason
				background.draw(0,0,1080*FACTOR,1920*FACTOR); //ofGetWidth(),ofGetHeight());
			ofPopMatrix(); //Restore the coordinate system

			int colinitialoffset=40;
			int rowinitialoffset=60;
			int coloffset=520;
			int imgsize=480;
			int rowoffset=615;
			int col=0;
			int row=0;
			int cols=2;
			int textcolinset=10;
			int textrowinset=50;

			
			//some kind of rendering bug with textsuite means it has to go last or everything is dim

			bool imageWaiting=false;

			if (!items.empty()) {
		        for (int i = 0; i < items.size(); i++) {
		        
		            if (items[i].image->isAllocated()) {
		            	
		            	int imgx=(colinitialoffset+(col*coloffset))*FACTOR;
		            	int imgy=(rowinitialoffset+(row*rowoffset))*FACTOR;
		                items[i].image->draw(imgx,imgy,imgsize*FACTOR,imgsize*FACTOR);
		                myText.setText(items[i].caption);
		                myText.wrapTextX(imgsize*FACTOR);
		                myText.setColor(255,255,255,255);
		                myText.drawCenter(imgx+((imgsize*FACTOR)/2),imgy+((imgsize+textcolinset)*FACTOR),2);
		                
		                myText.setText(items[i].price);
		                myText.wrapTextX(imgsize*FACTOR);
		                myText.setColor(255,255,255,255);
		                myText.drawCenter(imgx+((imgsize*FACTOR)/2),imgy+((imgsize+textcolinset+(FONTSPACING*2))*FACTOR),2);
		            }
		            else imageWaiting=true;

		            col++;
		            if (col==cols){
		            	col=0;
		            	row++;
		            }
		        }
		    }

		    ofEnableAlphaBlending();
			overlay.draw(0,0,1080*FACTOR,1920*FACTOR); //ofGetWidth(),ofGetHeight()); //don't work on a horiz screen??
			ofDisableAlphaBlending();

			//for some reason the final is only drawn on the frame AFTER all 5 images become allocated
			//hence the "primed" mechanism
			if (primed){
				ofImage img;
				//float rotation=ofDegToRad(ROTATION); 
				//int width=(1920*FACTOR*sin(rotation))+(1080*FACTOR*cos(rotation));
				//int height=(1920*FACTOR*cos(rotation))+(1080*FACTOR*sin(rotation));
				img.grabScreen(0, 0,1080*FACTOR,1920*FACTOR);
				if(ROTATION>0){
					img.rotate90(1);
					img.crop(860*FACTOR,0,1080*FACTOR,1920*FACTOR);
				}
				else {
					//img.crop(0,0,1080*FACTOR,1920*FACTOR);
				}
		    	img.save(ofFilePath().getUserHomeDir()+"/Dropbox/menugrab/"+SCREENGRABFILEPATH);
		    	primed=false;
			}

			if (!isGrabbed&&!imageWaiting) {
				primed=true;
				isGrabbed=true;
			}

		}

	ofPopMatrix();

}

//--------------------------------------------------------------
void ofApp::keyPressed(int key){

}

//--------------------------------------------------------------
void ofApp::keyReleased(int key){

}

//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y){

}

//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){

}

//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){

}

//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void ofApp::mouseEntered(int x, int y){

}

//--------------------------------------------------------------
void ofApp::mouseExited(int x, int y){

}

//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){

}

//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){

}

//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){ 

}
//--------------------------------------------------------------
void ofApp::exit()
{
    getImages.stopThread();
}