Examples

#include "helper_gphoto2.hpp"

#include <iostream>

int main(int argc, char* argv[]) {
	auto version = gphoto2pp::GetVersion();
	std::cout << "#############################" << std::endl;
	std::cout << "# Short Version - " << std::endl;
	std::cout << "#############################" << std::endl;
	std::cout << version << std::endl << std::endl;
	
	version = gphoto2pp::GetVersion(true);
	std::cout << "#############################" << std::endl;
	std::cout << "# Verbose Version - " << std::endl;
	std::cout << "#############################" << std::endl;
	std::cout << version << std::endl << std::endl;
}

#include "helper_gphoto2.hpp"
#include "camera_list_wrapper.hpp"
#include "exceptions.hpp"

#include <iostream>

int main(int argc, char* argv[]) {
	// runs autodetect method and returns all cameras connected to the computer
	std::cout << "#############################" << std::endl;
	std::cout << "# autoDetect - multiple     #" << std::endl;
	std::cout << "#############################" << std::endl;
	try
	{
		auto cameraList = gphoto2pp::autoDetectAll();
		
		for(int i = 0; i < cameraList.count(); ++i)
		{
			std::cout << "model: " << cameraList.getName(i) << std::endl;
		}
	}
	catch (const gphoto2pp::exceptions::NoCameraFoundError &e)
	{
		std::cout << "GPhoto couldn't detect any cameras connected to the computer" << std::endl;
		std::cout << "Exception Message: " << e.what() << std::endl;
	}
}

#include "helper_gphoto2.hpp"
#include "camera_wrapper.hpp"
#include "exceptions.hpp"

#include <iostream>

int main(int argc, char* argv[]) {
	std::string model;
	std::string port;
	
	// runs the autodetect method and returns the first camera we find (if any)
	std::cout << "#############################" << std::endl;
	std::cout << "# autoDetect - first camera #" << std::endl;
	std::cout << "#############################" << std::endl;
	try
	{
		auto cameraPair = gphoto2pp::autoDetect();
		std::cout << "model: " << cameraPair.first << " port: " << cameraPair.second << std::endl;
		
		model = cameraPair.first;
		port = cameraPair.second;
	}
	catch (gphoto2pp::exceptions::NoCameraFoundError &e)
	{
		std::cout << "gphoto2 couldn't detect any cameras connected to the computer" << std::endl;
		std::cout << "Exception Message: " << e.what() << std::endl;
	}
	
	try
	{
		std::cout << "connecting to the first camera (model and port above)..." << std::endl;
		auto cameraWrapper = gphoto2pp::CameraWrapper(model, port);
		
		std::cout << "#############################" << std::endl;
		std::cout << "# print camera summary      #" << std::endl;
		std::cout << "#############################" << std::endl;
		std::cout << cameraWrapper.getSummary() << std::endl;
	}
	catch (gphoto2pp::exceptions::gphoto2_exception& e)
	{
		std::cout << "gphoto2 Exception Code: " << e.getResultCode() << std::endl;
		std::cout << "Exception Message: " << e.what() << std::endl;
	}
}

#include "helper_camera_wrapper.hpp"
#include "camera_wrapper.hpp"
#include "camera_file_wrapper.hpp"
#include "camera_capture_type_wrapper.hpp"
#include "exceptions.hpp"

#include "window_widget.hpp"
#include "toggle_widget.hpp"

#include <iostream>
#include <fstream> // only for capture method 3

// This method is only needed for certain canon cameras. I had tested this on a Canon EOS Rebel T2i (shows as Canon EOS 550D) with the boolean set to true and false, and I noticed no difference. So you might need it or you might not depending on what camera you use.
void setCanonCapture(gphoto2pp::CameraWrapper& cameraWrapper, bool capture)
{
	try
	{
		auto captureWidget = cameraWrapper.getConfig().getChildByName<gphoto2pp::ToggleWidget>("capture");
		captureWidget.setValue(capture ? 1 : 0);
		cameraWrapper.setConfig(captureWidget);
	}
	catch(const std::runtime_error& e)
	{
		// Swallow the exception
		std::cout << "Tried to set canon capture, failed. The camera is probably not a canon" << std::endl;
	}
}

int main(int argc, char* argv[]) {
	try
	{
		std::cout << "#############################" << std::endl;
		std::cout << "# connect to camera         #" << std::endl;
		std::cout << "#############################" << std::endl;
		gphoto2pp::CameraWrapper cameraWrapper; // Not passing in model and port will connect to the first available camera.
		
		setCanonCapture(cameraWrapper, true);
		
		std::cout << "#############################" << std::endl;
		std::cout << "# Capture Method 1          #" << std::endl;
		std::cout << "#############################" << std::endl;
		std::cout << "Taking first picture..." << std::endl << std::endl;
		// Clean and quick capture and save to disk, but this assumes you are taking images, and in jpeg foramt. Adjust type and extension as appropriate.
		gphoto2pp::helper::capture(cameraWrapper, "example4_capture_method_2.jpg", true);
		
		std::cout << "#############################" << std::endl;
		std::cout << "# Capture Method 2          #" << std::endl;
		std::cout << "#############################" << std::endl;
		
		
		std::cout << "Taking second picture..." << std::endl << std::endl;
		gphoto2pp::CameraFileWrapper cameraFileWrapper;
		gphoto2pp::helper::capture(cameraWrapper, cameraFileWrapper, true);
		
		// This is only really needed if your camera is set to take pictures in RAW.
		// Because by default the mime type for those is 'application/unknown'
		cameraFileWrapper.detectMimeType();
		
		std::cout << "FileName (empty by default): "<< cameraFileWrapper.getFileName() << std::endl;
		
		std::cout << "MimeType: "<< cameraFileWrapper.getMimeType() << std::endl;
		
		// This will only set the extension for known mime types (application/unknown is not understood, and you should perform detectMimeType before this method)
		cameraFileWrapper.adjustNameForMimeType();
		std::cout << "FileName (still empty if the mime type is still unknown): "<< cameraFileWrapper.getFileName() << std::endl;
		
		// I choose a filename
		std::string fileName("example4_capture_method_1a." + cameraFileWrapper.getFileName());
		
		// Just for the purpose of demonstration, we will set the extension to something random
		// Again, the release notes say that the setFileName and getFileName will be going away, which I understand,
		// because it's not until we call the .save(fileName) method, that it's saved to the place with the directory.
		cameraFileWrapper.setFileName("TestRandom0293.odf");
		
		std::cout << "Delibrately incorrect filename and extension: "<< cameraFileWrapper.getFileName() << std::endl;
		
		// Should Fix the extension
		cameraFileWrapper.adjustNameForMimeType();
		
		std::cout << "FileName (proper extension): "<< cameraFileWrapper.getFileName() << std::endl;
		
		// Now after all that fiddling with filenames, we save the file and use our own filename (haha)
		std::cout << "FileName we will save with: "<< fileName << std::endl;
		cameraFileWrapper.save(fileName);
		
		// Now lets take another picture but ignore all of that messing around we did above and just use 4 lines of code instead :)
		std::cout << std::endl << "Taking third picture..." << std::endl << std::endl;
		//cameraFileWrapper = cameraWrapper.capture();
		gphoto2pp::helper::capture(cameraWrapper, cameraFileWrapper, true);
		cameraFileWrapper.detectMimeType();
		cameraFileWrapper.adjustNameForMimeType();
		cameraFileWrapper.save("example4_capture_method_1b."+cameraFileWrapper.getFileName());
		
		std::cout << "#############################" << std::endl;
		std::cout << "# Capture Method 3          #" << std::endl;
		std::cout << "#############################" << std::endl;
		std::cout << "Taking fourth picture..." << std::endl << std::endl;
		std::fstream f1("example4_capture_method_3.jpg",std::fstream::out|std::fstream::binary|std::fstream::trunc);
		gphoto2pp::helper::capture(cameraWrapper,f1, true);
		f1.close();
		
	}
	catch (gphoto2pp::exceptions::gphoto2_exception& e)
	{
		std::cout << "GPhoto Exception Code: " << e.getResultCode() << std::endl;
		std::cout << "Exception Message: " << e.what() << std::endl;
	}
}

void doRadioWidget(gphoto2pp::CameraWrapper& cameraWrapper, bool readOnly)
{
	auto rootWidget = cameraWrapper.getConfig();
	
	std::cout << std::endl << "#############################" << std::endl;
	std::cout << "# Radio Widget             #" << std::endl;
	std::cout << "#############################" << std::endl;
	
	// Now we will get the iso widget. We could use the name *iso*, but to change it up, we will use the label instead
	auto radioWidget = rootWidget.getChildByLabel<gphoto2pp::RadioWidget>("ISO Speed");
	std::cout << "\tReading iso Values" << std::endl;
	std::cout << "\t   label:\t" << radioWidget.getLabel() << std::endl;
	std::cout << "\t   info:\t " << radioWidget.getInfo() << std::endl;
	std::cout << "\t   type:\t" << static_cast<int>(radioWidget.getType()) << std::endl;
	std::cout << "\t   value:\t" << radioWidget.getValue() << std::endl;	
	std::cout << "\t   count:\t" << radioWidget.countChoices() << std::endl;	
	std::cout << "\t   choices:\t" << radioWidget.choicesToString(" ") << std::endl;
	
	if(readOnly == false)
	{
		std::cout << std::endl << "\tSetting radio..." << std::endl;
		try
		{
			radioWidget.setValue("400");
			cameraWrapper.setConfig(rootWidget);
			std::cout << "\t   done" << std::endl;
		}
		catch(gphoto2pp::exceptions::gphoto2_exception& e)
		{
			std::cout << "\tError: couldn't change the radio" << std::endl;
		}
		catch(gphoto2pp::exceptions::ValueOutOfLimits& e)
		{
			std::cout << "\tError: " << e.what() << std::endl;
		}
	}
}

#include "helper_camera_wrapper.hpp"
#include "camera_wrapper.hpp"
#include "camera_list_wrapper.hpp"

#include "exceptions.hpp"

#include <iostream>

/*
 * Example 9
 */

int main(int argc, char* argv[]) {
	
	try
	{
		std::cout << std::endl << "#############################" << std::endl;
		std::cout << "listing all files and folders may take quite some time if your memory card has a lot of pictures on it (I've had it take upwards of 30 seconds)" << std::endl;
		std::cout << "Please be patient...." << std::endl << std::endl;
		std::cout << "#############################" << std::endl;
		
		std::cout << "#############################" << std::endl;
		std::cout << "# List all folders          #" << std::endl;
		std::cout << "#############################" << std::endl;
		
		gphoto2pp::CameraWrapper cameraWrapper;
	
		auto folders = gphoto2pp::helper::getAllFolders(cameraWrapper);
		
		for(auto i : folders)
		{
			std::cout << i << std::endl;
		}
		
		std::cout << std::endl << "#############################" << std::endl;
		std::cout << "# List all files          #" << std::endl;
		std::cout << "#############################" << std::endl;
		
		auto files = gphoto2pp::helper::getAllFiles(cameraWrapper);
		
		for(auto i : files)
		{
			std::cout << i << std::endl;
		}
		
		std::cout << std::endl << "#############################" << std::endl;
		std::cout << "# List individual folder    #" << std::endl;
		std::cout << "#############################" << std::endl;
		
		// The two helpers used above access this method, as well as folderListFiles
		// They are convienence methods, use this directly if you please
		auto clw = cameraWrapper.folderListFolders("/");
		
		if(clw.count() > 0)
		{
			std::cout << "'" << clw.getName(0) << "' and '" << clw.getValue(0) << "'" << std::endl;
		}
	}
	catch (gphoto2pp::exceptions::gphoto2_exception& e)
	{
		std::cout << "GPhoto Exception Code: " << e.getResultCode() << std::endl;
		std::cout << "Exception Message: " << e.what() << std::endl;
	}
}

#include "camera_wrapper.hpp"
#include "camera_file_wrapper.hpp"
#include "camera_file_type_wrapper.hpp"
#include "camera_file_path_wrapper.hpp"
#include "camera_event_type_wrapper.hpp" // For the subscribeToCameraEvent(...) method
#include "exceptions.hpp"

#include <iostream>
#include <functional>

/*
 * Example 10 Tethered
 */
 
// Only used for the registration2 part, just to show how you can also bind to a class method
struct MyTestHandlerClass
{
	void mySuperSpecialHandler(const gphoto2pp::CameraFilePathWrapper& cameraFilePath, const std::string& data) const
	{
		std::cout << "My Super Special Handler was Triggered with file: " << cameraFilePath.Name << std::endl;
	}
};

int main(int argc, char* argv[]) {
	using namespace std::placeholders;	// for _1, _2, _3, see http://en.cppreference.com/w/cpp/utility/functional/bind for more details
	try
	{
		std::cout << "#############################" << std::endl;
		std::cout << "# Tethered listener         #" << std::endl;
		std::cout << "#############################" << std::endl;
		
		gphoto2pp::CameraWrapper cameraWrapper;
		
		// Create our event handler
		auto myhandler = [&cameraWrapper](const gphoto2pp::CameraFilePathWrapper& cameraFilePath, const std::string& data)
		{
			std::cout << "File Added: " << cameraFilePath.Name << std::endl;
			std::cout << "Downloading... " << std::endl;
			auto cameraFile = cameraWrapper.fileGet( cameraFilePath.Folder, cameraFilePath.Name, gphoto2pp::CameraFileTypeWrapper::Normal);
			cameraFile.save("example10_"+cameraFilePath.Name);
			std::cout << "Done!" << std::endl;
		};
		
		// Subscribe to the event we want with our handler
		auto registration = cameraWrapper.subscribeToCameraEvent(gphoto2pp::CameraEventTypeWrapper::FileAdded, myhandler);
		
		// An alternate way to show handler registration
		MyTestHandlerClass mthc;
		auto registration2 = cameraWrapper.subscribeToCameraEvent(gphoto2pp::CameraEventTypeWrapper::FileAdded, std::bind(&MyTestHandlerClass::mySuperSpecialHandler, std::cref(mthc), _1, _2));
		
		// Start listening for events from the camera.
		cameraWrapper.startListeningForEvents();
		
		std::string input = "";
		std::cout << "Press <enter> to quit at any time." << std::endl;
		std::cout << "Now pick up your camera and take some pictures as you normally would!" << std::endl;
		std::getline(std::cin, input);
				
	}
	catch (gphoto2pp::exceptions::gphoto2_exception& e)
	{
		std::cout << "GPhoto Exception Code: " << e.getResultCode() << std::endl;
		std::cout << "Exception Message: " << e.what() << std::endl;
	}
}