Some fixes and added information regarding running the program

AlterBrightness.cpp

@@ -1,27 +1,41 @@
 #include <iostream>
+#include <cstring>
 #include <fstream>
 #include <ios>
 #include "AlterBrightness.h"
-#include "Brightness.h"
 
 AlterBrightness::AlterBrightness()
 {
 	currentBrightness = Brightness::getCurrentBrightness();
 	maxBrightness = Brightness::getMaxBrightness();
+	AlterBrightness::options = new std::vector<std::string>;
+	initializeOptions();
 }	
-AlterBrightness::AlterBrightness(unsigned& change, unsigned& current, unsigned& max)
+AlterBrightness::AlterBrightness(Brightness* br)
+{
+	currentBrightness = (*br).getCurrentBrightness();
+	maxBrightness = (*br).getMaxBrightness();
+	options = new std::vector<std::string>;
+	initializeOptions();
+	
+}
+AlterBrightness::AlterBrightness(const unsigned& change, const unsigned& current, const unsigned& max)
 {
 	increment = change;
 	decrement = change;
 	currentBrightness = current;
 	maxBrightness = max;
 }	
+AlterBrightness::~AlterBrightness()
+{
+	delete options;
+}
 
-void AlterBrightness::setIncrement(unsigned& change)
+void AlterBrightness::setIncrement(const unsigned& change)
 {
 	increment = change;
 }	
-void AlterBrightness::setDecrement(unsigned& change)
+void AlterBrightness::setDecrement(const unsigned& change)
 {
 	decrement = change;
 }	
@@ -35,37 +49,48 @@ void AlterBrightness::setMaxBrightness()
 	maxBrightness = max;
 }	
 */
-void AlterBrightness::setPercentageBrightness(float& percent)
+void AlterBrightness::setPercentageBrightness(const float& percent)
 {
 	percentageBrightness = percent;
 }
+void AlterBrightness::initializeOptions()
+{
+	(*options).push_back("inc");
+	(*options).push_back("dec");
+	(*options).push_back("per");
+}
 
-void AlterBrightness::chooseChange(char* changeChoice[])
+void AlterBrightness::chooseChange(const std::string& changeChoice)
 {
 	std::ofstream s;
 	s.open("/sys/class/backlight/intel_backlight/brightness", std::ios::out);
+	//std::cout << (*options).at(0) << std::endl;
 
-	if (strcmp(*changeChoice, AlterBrightness::getIncrease()) == 0)
+	//if (strcmp(*changeChoice, getIncrease()) == 0)
+	//if (strcmp(*changeChoice, (*options).at(0)) == 0)
+	if ((*options).at(0).compare(changeChoice) == 0)
 	{
-		AlterBrightness::increaseBrightness();			
+		increaseBrightness();			
 
-		std::cout << AlterBrightness::getCurrentBrightness() << std::endl;
-		s << AlterBrightness::getCurrentBrightness();
+		std::cout << getCurrentBrightness() << std::endl;
+		s << getCurrentBrightness();
 	}
-	else if (strcmp(*changeChoice, AlterBrightness::getDecrease()) == 0)
+	//else if (strcmp(*changeChoice, getDecrease()) == 0)
+	else if ((*options).at(1).compare(changeChoice) == 0)
 	{
-		AlterBrightness::decreaseBrightness();
+		decreaseBrightness();
 
-		std::cout << AlterBrightness::getCurrentBrightness() << std::endl;
-		s << AlterBrightness::getCurrentBrightness();
+		std::cout << getCurrentBrightness() << std::endl;
+		s << getCurrentBrightness();
 	}	
-	else if (strcmp(*changeChoice, AlterBrightness::getPercent()) == 0)
+	//else if (strcmp(*changeChoice, getPercent()) == 0)
+	else if ((*options).at(2).compare(changeChoice) == 0)
 	{
 
-		std::cout << "Percentage" << std::endl;
+		//std::cout << "Percentage" << std::endl;
 		setBrightnessByPercentage();
 
-		std::cout << percentageBrightness / 100 << std::endl;
+		std::cout << percentageBrightness << "%" << std::endl;
 		s << currentBrightness;
 	}
 	else
@@ -76,36 +101,41 @@ void AlterBrightness::chooseChange(char* changeChoice[])
 }	
 void AlterBrightness::increaseBrightness()
 {
-	if (AlterBrightness::getCurrentBrightness() + AlterBrightness::getIncrement() < AlterBrightness::getMaxBrightness())
+	if (getCurrentBrightness() + getIncrement() < getMaxBrightness())
 	{
-		currentBrightness = AlterBrightness::getCurrentBrightness() + AlterBrightness::getIncrement();
+		currentBrightness = getCurrentBrightness() + getIncrement();
 	}
 	else
-		currentBrightness = AlterBrightness::getMaxBrightness();
+		currentBrightness = getMaxBrightness();
 }	
 void AlterBrightness::decreaseBrightness()
 {
-	if (AlterBrightness::getCurrentBrightness() - AlterBrightness::getDecrement() > 0)
+	if (getCurrentBrightness() - getDecrement() > 0)
 	{
-	currentBrightness = AlterBrightness::getCurrentBrightness() - AlterBrightness::getDecrement();
+	currentBrightness = getCurrentBrightness() - getDecrement();
 	}
 	else
 		currentBrightness = 1;
 }	
 void AlterBrightness::setBrightnessByPercentage()
 {
-	if (AlterBrightness::getPercentageBrightness() < 0 || AlterBrightness::getPercentageBrightness() > 100)
+	if (getPercentageBrightness() < 0 || getPercentageBrightness() > 100)
 	{
 		std::cout << "Has to be between 0 and 100" <<std::endl;
 	}
 	else
 	{
-		currentBrightness = (maxBrightness * (percentageBrightness/ 100));
+		currentBrightness = (maxBrightness * (floatToPercent(percentageBrightness)));
 		std::cout << currentBrightness << std::endl;
 	}
 }
 
 
+std::vector<std::string>* AlterBrightness::getOptions()
+{
+	return options;
+}
+
 unsigned AlterBrightness::getIncrement() const 
 {
 	return increment;
@@ -123,11 +153,17 @@ unsigned AlterBrightness::getMaxBrightness() const
 	return maxBrightness;
 }		
 
+
 float AlterBrightness::getPercentageBrightness() const
 {
 	return percentageBrightness;
 }
+float AlterBrightness::floatToPercent(const float& percent) const
+{
+	return percent / 100;
+}
 
+/**
 char* AlterBrightness::getIncrease() 
 {
 	return increase;
@@ -140,3 +176,4 @@ char* AlterBrightness::getPercent()
 {
 	return percent;
 }
+*/

AlterBrightness.h

@@ -2,25 +2,33 @@
 #define ALTERBRIGHTNESS_H
 #include <cstring>
 #include <string>
+#include <vector>
+#include "Brightness.h"
 
 class AlterBrightness
 {
 public:	
 	AlterBrightness();
+	AlterBrightness(Brightness*);
+	AlterBrightness(const unsigned&, const unsigned&, const unsigned&);
 
-	AlterBrightness(unsigned&, unsigned&, unsigned&);
+	~AlterBrightness();
 
-	void setIncrement(unsigned&);
-	void setDecrement(unsigned&);
+	std::vector<std::string>* options;
+
+	void setIncrement(const unsigned&);
+	void setDecrement(const unsigned&);
 	void setCurrentBrightness();
 	void setMaxBrightness();
-	void setPercentageBrightness(float&);
+	void setPercentageBrightness(const float&);
+	void initializeOptions();
 	
-	void chooseChange(char*[]);
+	void chooseChange(const std::string&);
 	void increaseBrightness();
 	void decreaseBrightness();
 	void setBrightnessByPercentage();
 
+	std::vector<std::string>* getOptions();
 
 	unsigned getIncrement() const;
 	unsigned getDecrement() const;
@@ -28,10 +36,13 @@ public:
 	unsigned getMaxBrightness() const;
 
 	float getPercentageBrightness() const;
+	float floatToPercent(const float&) const;
 
+	/**
 	char* getIncrease();
 	char* getDecrease();
 	char* getPercent();
+	*/
 	
 private:	
 	unsigned increment;
@@ -39,9 +50,11 @@ private:
 	unsigned currentBrightness;
 	unsigned maxBrightness;
 	float percentageBrightness;
-	char* increase = "inc";
-	char* decrease = "dec";
-	char* percent = "per";
+	/**
+	char* increase;
+	char* decrease;
+	char* percent;
+	*/
 };
 
 #endif

Brightness.cpp

@@ -6,25 +6,36 @@ unsigned Brightness::maxBrightness = 0;
 unsigned Brightness::currentBrightness = 30;
 Brightness::Brightness()
 {
+	readBrightnessValues = new std::ifstream;
+}	
+Brightness::~Brightness()
+{
+	delete readBrightnessValues;
 }
 
 void Brightness::grabBrightness()
 {
-	std::fstream input;
-	input.open("/sys/class/backlight/intel_backlight/brightness", std::ios::in);
+	//std::fstream input;
+	//input.open("/sys/class/backlight/intel_backlight/brightness", std::ios::in);
+	(*readBrightnessValues).open("/sys/class/backlight/intel_backlight/brightness", std::ios::in);
 
-	input >> currentBrightness;
+	//input >> currentBrightness;
+	(*readBrightnessValues) >> currentBrightness;
 	
-	input.close();
+	(*readBrightnessValues).close();
+	//input.close();
 }	
 void Brightness::grabMaxBrightness()
 {
-	std::fstream input;
-	input.open("/sys/class/backlight/intel_backlight/max_brightness", std::ios::in);
+	//std::fstream input;
+	//input.open("/sys/class/backlight/intel_backlight/max_brightness", std::ios::in);
+	(*readBrightnessValues).open("/sys/class/backlight/intel_backlight/max_brightness", std::ios::in);
 
-	input >> maxBrightness;
+	//input >> maxBrightness;
+	(*readBrightnessValues) >> maxBrightness;
 
-	input.close();
+	(*readBrightnessValues).close();
+	//input.close();
 }
 
 unsigned Brightness::getCurrentBrightness()

Brightness.h

@@ -1,10 +1,12 @@
 #ifndef BRIGHTNESS_H 
 #define BRIGHTNESS_H
+#include <fstream>
 
 class Brightness
 {
 public:
 	Brightness();
+	~Brightness();
 
 	void grabBrightness();
 	void grabMaxBrightness();
@@ -13,6 +15,7 @@ public:
 	static unsigned getMaxBrightness();
 
 private:
+	std::ifstream* readBrightnessValues;
 	static unsigned currentBrightness;
 	static unsigned maxBrightness;
 };	

BrightnessControl.cpp

@@ -1,29 +1,79 @@
 #include <iostream>
+#include <iomanip>
 #include <fstream>
 #include "AlterBrightness.h"
 #include "Brightness.h"
 
 int main(int argc, char* argv[])
 {
-	char* control[strlen(*(argv + 1))] = {*(argv + 1)};
+
+	//char* control[strlen(*(argv + 1))] = {*(argv + 1)};
+	//unsigned currentBrightness;
+	//unsigned maxBrightness;
+	
+	Brightness* br = new Brightness;
+	//std::cout << "argc is: " << argc << std::endl;
+	if (argc == 3)
+	{
+		std::string control = *(argv + 1);
 		unsigned changeAmount = atoi(*(argv + 2));
 		float brightnessPercentage = atoi(*(argv + 2));
-	unsigned currentBrightness;
-	unsigned maxBrightness;
+		
+		(*br).grabBrightness();
+		(*br).grabMaxBrightness();
+
+		
+		AlterBrightness* ab = new AlterBrightness(br);
+		delete br;
+		(*ab).setIncrement(changeAmount);
+		(*ab).setDecrement(changeAmount);
+		(*ab).setPercentageBrightness(brightnessPercentage);
+
+		(*ab).chooseChange((control));
+			
+		delete ab;
+	}
+	else
+	{
+		std::cout << "Inlude one of the following arguements: " << std::endl;
+		std::cout << std::setw(10) << "inc"; 
+		std::cout << std::setw(10) << "dec";
+		std::cout << std::setw(10) << "per" << std::endl << std::endl;
+
+
+		std::cout << "If inc or dec add a value to adjust the brightness by value" << std::endl;
+		std::cout << "If per add a value between 0 and 100 to adjust the brightness by percentage" << std::endl;
+		std::cout << "Adjusting the percentage by brightness is recommended" << std::endl << std::endl;
+		std::cout << "Example: Hot.out per 30" << std::endl << std::endl;
+	
+	}
+	/**
+	switch(argc)
+	{
+		case 3: 
+			//std::cout << "two" << std::endl;
 		
 		
 			
-	Brightness br;
-	br.grabBrightness();
-	br.grabMaxBrightness();
-	AlterBrightness ab;
+			AlterBrightness* ab = new AlterBrightness;
+			delete br;
+			(*ab).setIncrement(changeAmount);
+			(*ab).setDecrement(changeAmount);
+			(*ab).setPercentageBrightness(brightnessPercentage);
+
+			(*ab).chooseChange((control));
+			
+			delete ab;
+			break;
+		default:
 			
 
-	ab.setIncrement(changeAmount);
-	ab.setDecrement(changeAmount);
-	ab.setPercentageBrightness(brightnessPercentage);
+			break;
+	}
+	*/
 
-	ab.chooseChange((control));
+
+	//PointerRemoval pR;
 
 	return 0;
 }