The top-level manager of templates. More...

#include <templatefactory.h>

Collaboration diagram for TemplateFactory:

Public Slots
void	quit ()
	Quits running actions of template manager.

bool	startNewProject (TemplateEntryPoint *entry_point)
	Starts new project core from given entry point. More...

bool	loadProject (const QString &bundle_file_name)
	Loads stored project and initializes new core according to it. More...

bool	saveCurrentProjectAs (const QString &bundle_file_name)
	Saves current project to given file. More...

bool	saveCurrentProject ()
	Saves current project to assigned file if there is any. More...

Signals
void	newTemplateCoreCreated (TemplateCore *core)
	Emitted if new project using some template core is started. More...

Public Member Functions
	TemplateFactory (QObject *parent=0)

QList< TemplateEntryPoint * >	availableTemplates ()
	Access to available templates. More...

QString	tempDirectory () const
	Access to temporary directory used throughout APK generation process. More...

void	setTempDirectory (const QString &temp_directory)

QString	outputDirectory () const
	Access to directory used throughout APK generation process. More...

void	setOutputDirectory (const QString &output_directory)

QString	applicationFileNamePattern () const
	Access to pattern used for name of output APK file. More...

void	setApplicationFileNamePattern (const QString &file_name_pattern)

QString	applicationFileName (const QString &project_name)
	Generates file name for output APK file. More...

TemplateEntryPoint *	activeEntryPoint () const
	Access to active entry point. More...

TemplateCore *	activeCore () const
	Access to active core. More...

QDomDocument	generateBundleHeader (const QString &template_type, const QString &author_name, const QString &author_email, const QString &project_title, const QString &project_description, const QString &template_version)
	Generates common XML bundle. More...

TemplateGenerator *	generator () const
	Access to component which supervises generating of APK files. More...

TemplateEntryPoint *	entryPointForBundle (const QString &bundle_data)
	Decides which entry point raw XML bundle data belong to. More...

Static Public Member Functions
static bool	entryPointIsLessThan (TemplateEntryPoint *s1, TemplateEntryPoint &s2)
	Performs lexicographical comparison of two entry points. More...

Detailed Description

The top-level manager of templates.

This class is used in a singleton-like fashion from main Application object via Application::templateManager(). It contains all available template entry points.

See also: TemplateEntryPoint, TemplateCore, Application

Definition at line 69 of file templatefactory.h.

Member Function Documentation

TemplateCore* TemplateFactory::activeCore ( ) const

inline

Access to active core.

Returns: Returns pointer to active core or NULL if not core is active.

Definition at line 115 of file templatefactory.h.

                                      {
       return m_activeCore;
     }

Here is the caller graph for this function:

TemplateEntryPoint* TemplateFactory::activeEntryPoint ( ) const

inline

Access to active entry point.

Returns: Returns pointer to active entry point or NULL if no entry point is active.

Definition at line 109 of file templatefactory.h.

                                                  {
       return m_activeEntryPoint;
     }

Here is the caller graph for this function:

QString TemplateFactory::applicationFileName ( const QString & project_name )

Generates file name for output APK file.

Parameters

project_name Name of source project.

Returns: Access to output APK application file name pattern.

Definition at line 123 of file templatefactory.cpp.

                                                                         {
   if (activeEntryPoint() != NULL) {
     return applicationFileNamePattern().arg(activeEntryPoint()->name(),
                                             project_name,
                                             QDateTime::currentDateTime().toString("yyyyMMddThhmmss"));
   }
   else {
     return QString();
   }
 }

Here is the call graph for this function:

QString TemplateFactory::applicationFileNamePattern ( ) const

Access to pattern used for name of output APK file.

Returns: Returns pattern used for name of output APK file.

Definition at line 114 of file templatefactory.cpp.

                                                           {
   return qApp->settings()->value(APP_CFG_TEMPLATES, "application_file_name_pattern",
                                  "application-%1-%2-%3.apk").toString();
 }

Here is the caller graph for this function:

QList< TemplateEntryPoint * > TemplateFactory::availableTemplates ( )

Access to available templates.

See also: TemplateEntryPoint

Returns: Method returns list of available templates. Templates are not sorted in any particular order.

Definition at line 67 of file templatefactory.cpp.

                                                                {
   QList<TemplateEntryPoint*> entries;
 
   foreach (TemplateEntryPoint *entry, m_availableTemplates.values()) {
     for (int i = 0; i <= entries.size(); i++) {
       if (i == entries.size()) {
         entries.append(entry);
         break;
       }
       else if (entry->humanName() < entries.at(i)->humanName()) {
         entries.insert(i, entry);
         break;
       }
     }
   }
 
   return entries;
 }

Here is the call graph for this function:

TemplateEntryPoint * TemplateFactory::entryPointForBundle ( const QString & bundle_data )

Decides which entry point raw XML bundle data belong to.

Parameters

bundle_data Raw XML bundle data.

Returns: Returns pointer to appropriate entry point or NULL if no correct entry point exists.

Definition at line 250 of file templatefactory.cpp.

                                                                                    {
   if (bundle_data.isEmpty()) {
     return NULL;
   }
 
   QDomDocument xml_document;
   xml_document.setContent(bundle_data);
 
   return m_availableTemplates.value(xml_document.documentElement().attribute("type"), NULL);
 }

Here is the caller graph for this function:

bool TemplateFactory::entryPointIsLessThan	(	TemplateEntryPoint *	s1,
		TemplateEntryPoint &	s2
	)

static

Performs lexicographical comparison of two entry points.

Note: This is used for sorting entry points in FormNewProject class.

Parameters

s1	First entry point.
s2	Second entry point.

Returns: Returns true if s1 is less than s2, otherwise returns false.

Definition at line 167 of file templatefactory.cpp.

                                                                                          {
   return s1->humanName() < s2.humanName();
 }

Here is the call graph for this function:

QDomDocument TemplateFactory::generateBundleHeader	(	const QString &	template_type,
		const QString &	author_name,
		const QString &	author_email,
		const QString &	project_title,
		const QString &	project_description,
		const QString &	template_version
	)

Generates common XML bundle.

Returns: Returns XML bundle structure.

Definition at line 134 of file templatefactory.cpp.

                                                                                                                                                                                                                                            {
   QDomDocument xml_bundle;
   QDomElement root_element = xml_bundle.createElement("buildmlearn_application");
   QDomElement author_element = xml_bundle.createElement("author");
   QDomElement name_element = xml_bundle.createElement("name");
   QDomElement email_element = xml_bundle.createElement("email");
   QDomElement title_element = xml_bundle.createElement("title");
   QDomElement description_element = xml_bundle.createElement("description");
   QDomElement version_element = xml_bundle.createElement("version");
   QDomElement data_element = xml_bundle.createElement("data");
 
 
   root_element.setAttribute("type", template_type);
   name_element.appendChild(xml_bundle.createTextNode(author_name));
   email_element.appendChild(xml_bundle.createTextNode(author_email));
   title_element.appendChild(xml_bundle.createTextNode(project_title));
   description_element.appendChild(xml_bundle.createTextNode(project_description));
   version_element.appendChild(xml_bundle.createTextNode(template_version));
 
   author_element.appendChild(name_element);
   author_element.appendChild(email_element);
 
   root_element.appendChild(author_element);
   root_element.appendChild(title_element);
   root_element.appendChild(description_element);
   root_element.appendChild(version_element);
   root_element.appendChild(data_element);
 
   xml_bundle.appendChild(root_element);
 
   return xml_bundle;
 }

TemplateGenerator * TemplateFactory::generator ( ) const

Access to component which supervises generating of APK files.

Returns: Returns pointer to generator.

Definition at line 318 of file templatefactory.cpp.

                                                     {
   return m_generator;
 }

bool TemplateFactory::loadProject ( const QString & bundle_file_name )

slot

Loads stored project and initializes new core according to it.

Parameters

bundle_file_name XML bundle file name of saved project.

Definition at line 197 of file templatefactory.cpp.

                                                                  {
   // TODO: Load project from XML bundle file.
   // Detect which template is it, then start new project with that template
   // and fill data in.
 
   QFile bundle_file(bundle_file_name);
 
   if (!bundle_file.open(QIODevice::Text | QIODevice::ReadOnly | QIODevice::Unbuffered)) {
     qApp->trayIcon()->showMessage(tr("Cannot load XML bundle"),
                                   tr("Bundle cannot be loaded because XML file cannot be opened for reading."),
                                   QSystemTrayIcon::Critical);
 
     return false;
   }
 
   // Bundle file is opened, read its contents and determine which template entry point
   // it belongs to.
   QString bundle_data(bundle_file.readAll());
   bundle_file.close();
 
   TemplateEntryPoint *target_entry_point = entryPointForBundle(bundle_data);
 
   if (target_entry_point == NULL) {
     qApp->trayIcon()->showMessage(tr("Cannot load XML bundle"),
                                   tr("Bundle cannot be loaded because XML file is corrupted."),
                                   QSystemTrayIcon::Critical);
 
     return false;
   }
 
   TemplateCore *loaded_core = target_entry_point->loadCoreFromBundleData(bundle_data);
 
   if (loaded_core == NULL) {
     qApp->trayIcon()->showMessage(tr("Cannot load XML bundle"),
                                   tr("Target template was not able to load XML bundle data."),
                                   QSystemTrayIcon::Critical);
 
     return false;
   }
 
   // Clear previous data and start loaded core.
   clearEntryAndCore();
   loaded_core->setAssignedFile(bundle_file_name);
   loaded_core->editor()->setIsDirty(false);
 
   m_activeEntryPoint = target_entry_point;
   m_activeCore = loaded_core;
 
   emit newTemplateCoreCreated(m_activeCore);
 
   return true;
 }

Here is the call graph for this function:

void TemplateFactory::newTemplateCoreCreated ( TemplateCore * core )

signal

Emitted if new project using some template core is started.

Parameters

core	Core object pointer.

Here is the caller graph for this function:

QString TemplateFactory::outputDirectory ( ) const

Access to directory used throughout APK generation process.

Returns: Returns output directory used throughout APK generation process.

Definition at line 100 of file templatefactory.cpp.

                                                {
 #if QT_VERSION >= 0x050000
   return qApp->settings()->value(APP_CFG_TEMPLATES, "output_directory",
                                  QStandardPaths::writableLocation(QStandardPaths::DesktopLocation)).toString();
 #else
   return qApp->settings()->value(APP_CFG_TEMPLATES, "output_directory",
                                  QDesktopServices::storageLocation(QDesktopServices::DesktopLocation)).toString();
 #endif
 }

bool TemplateFactory::saveCurrentProject ( )

slot

Saves current project to assigned file if there is any.

Returns: Returns true if project was saved, otherwise returns false.

Definition at line 294 of file templatefactory.cpp.

                                          {
   if (activeCore() == NULL || activeCore()->assignedFile().isEmpty()) {
     return false;
   }
   else {
     return saveCurrentProjectAs(activeCore()->assignedFile());
   }
 }

Here is the call graph for this function:

bool TemplateFactory::saveCurrentProjectAs ( const QString & bundle_file_name )

slot

Saves current project to given file.

Parameters

bundle_file_name File to save project XML bundle to.

Returns: Returns true if project was saved, otherwise returns false.

Definition at line 261 of file templatefactory.cpp.

                                                                           {
   // TODO: Save current project to given file.
 
   QString xml_bundle_contents = activeCore()->editor()->generateBundleData();
 
   if (xml_bundle_contents.isEmpty()) {
     // There is nothing to save. This is quite problem.
     qWarning("There is nothing to save for template \"%s\".", qPrintable(activeCore()->entryPoint()->humanName()));
     return false;
   }
 
   QFile target_xml_file(bundle_file_name);
 
   if (target_xml_file.open(QIODevice::Truncate | QIODevice::WriteOnly |
                            QIODevice::Unbuffered | QIODevice::Text)) {
     QTextStream stream(&target_xml_file);
 
     stream << xml_bundle_contents;
     stream.flush();
 
     target_xml_file.flush();
     target_xml_file.close();
 
     activeCore()->setAssignedFile(bundle_file_name);
     activeCore()->editor()->setIsDirty(false);
 
     return true;
   }
   else {
     return false;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool TemplateFactory::startNewProject ( TemplateEntryPoint * entry_point )

slot

Starts new project core from given entry point.

Parameters

entry_point Entry point to be started.

Definition at line 185 of file templatefactory.cpp.

                                                                      {
   // Start new project with selected template entry point.
   clearEntryAndCore();
 
   m_activeEntryPoint = entry_point;
   m_activeCore = entry_point->createNewCore();
 
   emit newTemplateCoreCreated(m_activeCore);
 
   return true;
 }

Here is the call graph for this function:

QString TemplateFactory::tempDirectory ( ) const

Access to temporary directory used throughout APK generation process.

Returns: Returns temporary directory used throughout APK generation process.

Definition at line 86 of file templatefactory.cpp.

                                              {
 #if QT_VERSION >= 0x050000
   return qApp->settings()->value(APP_CFG_TEMPLATES, "temp_directory",
                                  QStandardPaths::writableLocation(QStandardPaths::TempLocation)).toString();
 #else
   return qApp->settings()->value(APP_CFG_TEMPLATES, "temp_directory",
                                  QDesktopServices::storageLocation(QDesktopServices::TempLocation)).toString();
 #endif
 }

The documentation for this class was generated from the following files:

Public Slots

Signals

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation