Modules/FindosgManipulator.cmake


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

# This is part of the Findosg* suite used to find OpenSceneGraph components.
# Each component is separate and you must opt in to each module. You must 
# also opt into OpenGL and OpenThreads (and Producer if needed) as these 
# modules won't do it for you. This is to allow you control over your own 
# system piece by piece in case you need to opt out of certain components
# or change the Find behavior for a particular module (perhaps because the
# default FindOpenGL.cmake module doesn't work with your system as an
# example).
# If you want to use a more convenient module that includes everything,
# use the FindOpenSceneGraph.cmake instead of the Findosg*.cmake modules.
# 
# Locate osgManipulator
# This module defines
# OSG_LIBRARY
# OSGMANIPULATOR_FOUND, if false, do not try to link to osgManipulator
# OSGMANIPULATOR_INCLUDE_DIR, where to find the headers
#
# $OSGDIR is an environment variable that would
# correspond to the ./configure --prefix=$OSGDIR
# used in building osg.
#
# Created by Eric Wing.

# Header files are presumed to be included like
# #include <osg/PositionAttitudeTransform>
# #include <osgManipulator/TrackballDragger>

# Try the user's environment request before anything else.
FIND_PATH(OSGMANIPULATOR_INCLUDE_DIR osgManipulator/TrackballDragger
  PATHS
  $ENV{OSGMANIPULATOR_DIR}
  $ENV{OSG_DIR}
  $ENV{OSGDIR}
  NO_DEFAULT_PATH
  PATH_SUFFIXES include
)
FIND_PATH(OSGMANIPULATOR_INCLUDE_DIR osgManipulator/TrackballDragger
  PATHS ${CMAKE_PREFIX_PATH} # Unofficial: We are proposing this.
  NO_DEFAULT_PATH
  PATH_SUFFIXES include
)
FIND_PATH(OSGMANIPULATOR_INCLUDE_DIR osgManipulator/TrackballDragger
  PATHS
    ~/Library/Frameworks
    /Library/Frameworks
    /usr/local
    /usr
    /sw # Fink
    /opt/local # DarwinPorts
    /opt/csw # Blastwave
    /opt
    [HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session\ Manager\\Environment;OpenThreads_ROOT]
    [HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session\ Manager\\Environment;OSG_ROOT]
  PATH_SUFFIXES include
)

FIND_LIBRARY(OSGMANIPULATOR_LIBRARY 
  NAMES osgManipulator
  PATHS
  $ENV{OSGMANIPULATOR_DIR}
  $ENV{OSG_DIR}
  $ENV{OSGDIR}
  NO_DEFAULT_PATH
    PATH_SUFFIXES lib64 lib
)
FIND_LIBRARY(OSGMANIPULATOR_LIBRARY 
  NAMES osgManipulator
  PATHS ${CMAKE_PREFIX_PATH} # Unofficial: We are proposing this.
    NO_DEFAULT_PATH
    PATH_SUFFIXES lib64 lib
)
FIND_LIBRARY(OSGMANIPULATOR_LIBRARY 
  NAMES osgManipulator
  PATHS
    ~/Library/Frameworks
    /Library/Frameworks
  /usr/local
  /usr
  /sw
  /opt/local
  /opt/csw
  /opt
    PATH_SUFFIXES lib64 lib
)

SET(OSGMANIPULATOR_FOUND "NO")
IF(OSGMANIPULATOR_LIBRARY AND OSGMANIPULATOR_INCLUDE_DIR)
  SET(OSGMANIPULATOR_FOUND "YES")
ENDIF(OSGMANIPULATOR_LIBRARY AND OSGMANIPULATOR_INCLUDE_DIR)
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include "cmCPackIFWRepository.h"

#include "CPack/cmCPackGenerator.h"
#include "cmCPackIFWGenerator.h"
#include "cmGeneratedFileStream.h"
#include "cmSystemTools.h"
#include "cmXMLParser.h"
#include "cmXMLWriter.h"

#include <cmConfigure.h>
#include <stddef.h>

#ifdef cmCPackLogger
#undef cmCPackLogger
#endif
#define cmCPackLogger(logType, msg)                                           \
  do {                                                                        \
    std::ostringstream cmCPackLog_msg;                                        \
    cmCPackLog_msg << msg;                                                    \
    if (Generator) {                                                          \
      Generator->Logger->Log(logType, __FILE__, __LINE__,                     \
                             cmCPackLog_msg.str().c_str());                   \
    }                                                                         \
  } while (0)

cmCPackIFWRepository::cmCPackIFWRepository()
  : Update(None)
  , Generator(CM_NULLPTR)
{
}

bool cmCPackIFWRepository::IsValid() const
{
  bool valid = true;

  switch (Update) {
    case None:
      valid = !Url.empty();
      break;
    case Add:
      valid = !Url.empty();
      break;
    case Remove:
      valid = !Url.empty();
      break;
    case Replace:
      valid = !OldUrl.empty() && !NewUrl.empty();
      break;
  }

  return valid;
}

const char* cmCPackIFWRepository::GetOption(const std::string& op) const
{
  return Generator ? Generator->GetOption(op) : CM_NULLPTR;
}

bool cmCPackIFWRepository::IsOn(const std::string& op) const
{
  return Generator ? Generator->IsOn(op) : false;
}

bool cmCPackIFWRepository::IsVersionLess(const char* version)
{
  return Generator ? Generator->IsVersionLess(version) : false;
}

bool cmCPackIFWRepository::IsVersionGreater(const char* version)
{
  return Generator ? Generator->IsVersionGreater(version) : false;
}

bool cmCPackIFWRepository::IsVersionEqual(const char* version)
{
  return Generator ? Generator->IsVersionEqual(version) : false;
}

bool cmCPackIFWRepository::ConfigureFromOptions()
{
  // Name;
  if (Name.empty()) {
    return false;
  }

  std::string prefix =
    "CPACK_IFW_REPOSITORY_" + cmsys::SystemTools::UpperCase(Name) + "_";

  // Update
  if (IsOn(prefix + "ADD")) {
    Update = Add;
  } else if (IsOn(prefix + "REMOVE")) {
    Update = Remove;
  } else if (IsOn(prefix + "REPLACE")) {
    Update = Replace;
  } else {
    Update = None;
  }

  // Url
  if (const char* url = GetOption(prefix + "URL")) {
    Url = url;
  } else {
    Url = "";
  }

  // Old url
  if (const char* oldUrl = GetOption(prefix + "OLD_URL")) {
    OldUrl = oldUrl;
  } else {
    OldUrl = "";
  }

  // New url
  if (const char* newUrl = GetOption(prefix + "NEW_URL")) {
    NewUrl = newUrl;
  } else {
    NewUrl = "";
  }

  // Enabled
  if (IsOn(prefix + "DISABLED")) {
    Enabled = "0";
  } else {
    Enabled = "";
  }

  // Username
  if (const char* username = GetOption(prefix + "USERNAME")) {
    Username = username;
  } else {
    Username = "";
  }

  // Password
  if (const char* password = GetOption(prefix + "PASSWORD")) {
    Password = password;
  } else {
    Password = "";
  }

  // DisplayName
  if (const char* displayName = GetOption(prefix + "DISPLAY_NAME")) {
    DisplayName = displayName;
  } else {
    DisplayName = "";
  }

  return IsValid();
}

/** \class cmCPackeIFWUpdatesPatcher
 * \brief Helper class that parses and patch Updates.xml file (QtIFW)
 */
class cmCPackeIFWUpdatesPatcher : public cmXMLParser
{
public:
  cmCPackeIFWUpdatesPatcher(cmCPackIFWRepository* r, cmXMLWriter& x)
    : repository(r)
    , xout(x)
    , patched(false)
  {
  }

  cmCPackIFWRepository* repository;
  cmXMLWriter& xout;
  bool patched;

protected:
  void StartElement(const std::string& name, const char** atts) CM_OVERRIDE
  {
    xout.StartElement(name);
    StartFragment(atts);
  }

  void StartFragment(const char** atts)
  {
    for (size_t i = 0; atts[i]; i += 2) {
      const char* key = atts[i];
      const char* value = atts[i + 1];
      xout.Attribute(key, value);
    }
  }

  void EndElement(const std::string& name) CM_OVERRIDE
  {
    if (name == "Updates" && !patched) {
      repository->WriteRepositoryUpdates(xout);
      patched = true;
    }
    xout.EndElement();
    if (patched) {
      return;
    }
    if (name == "Checksum") {
      repository->WriteRepositoryUpdates(xout);
      patched = true;
    }
  }

  void CharacterDataHandler(const char* data, int length) CM_OVERRIDE
  {
    std::string content(data, data + length);
    if (content == "" || content == " " || content == "  " ||
        content == "\n") {
      return;
    }
    xout.Content(content);
  }
};

bool cmCPackIFWRepository::PatchUpdatesXml()
{
  // Lazy directory initialization
  if (Directory.empty() && Generator) {
    Directory = Generator->toplevel;
  }

  // Filenames
  std::string updatesXml = Directory + "/repository/Updates.xml";
  std::string updatesPatchXml = Directory + "/repository/UpdatesPatch.xml";

  // Output stream
  cmGeneratedFileStream fout(updatesPatchXml.data());
  cmXMLWriter xout(fout);

  xout.StartDocument();

  WriteGeneratedByToStrim(xout);

  // Patch
  {
    cmCPackeIFWUpdatesPatcher patcher(this, xout);
    patcher.ParseFile(updatesXml.data());
  }

  xout.EndDocument();

  fout.Close();

  return cmSystemTools::RenameFile(updatesPatchXml.data(), updatesXml.data());
}

void cmCPackIFWRepository::WriteRepositoryConfig(cmXMLWriter& xout)
{
  xout.StartElement("Repository");

  // Url
  xout.Element("Url", Url);
  // Enabled
  if (!Enabled.empty()) {
    xout.Element("Enabled", Enabled);
  }
  // Username
  if (!Username.empty()) {
    xout.Element("Username", Username);
  }
  // Password
  if (!Password.empty()) {
    xout.Element("Password", Password);
  }
  // DisplayName
  if (!DisplayName.empty()) {
    xout.Element("DisplayName", DisplayName);
  }

  xout.EndElement();
}

void cmCPackIFWRepository::WriteRepositoryUpdate(cmXMLWriter& xout)
{
  xout.StartElement("Repository");

  switch (Update) {
    case None:
      break;
    case Add:
      xout.Attribute("action", "add");
      break;
    case Remove:
      xout.Attribute("action", "remove");
      break;
    case Replace:
      xout.Attribute("action", "replace");
      break;
  }

  // Url
  if (Update == Add || Update == Remove) {
    xout.Attribute("url", Url);
  } else if (Update == Replace) {
    xout.Attribute("oldUrl", OldUrl);
    xout.Attribute("newUrl", NewUrl);
  }
  // Enabled
  if (!Enabled.empty()) {
    xout.Attribute("enabled", Enabled);
  }
  // Username
  if (!Username.empty()) {
    xout.Attribute("username", Username);
  }
  // Password
  if (!Password.empty()) {
    xout.Attribute("password", Password);
  }
  // DisplayName
  if (!DisplayName.empty()) {
    xout.Attribute("displayname", DisplayName);
  }

  xout.EndElement();
}

void cmCPackIFWRepository::WriteRepositoryUpdates(cmXMLWriter& xout)
{
  if (!RepositoryUpdate.empty()) {
    xout.StartElement("RepositoryUpdate");
    for (RepositoriesVector::iterator rit = RepositoryUpdate.begin();
         rit != RepositoryUpdate.end(); ++rit) {
      (*rit)->WriteRepositoryUpdate(xout);
    }
    xout.EndElement();
  }
}

void cmCPackIFWRepository::WriteGeneratedByToStrim(cmXMLWriter& xout)
{
  if (Generator) {
    Generator->WriteGeneratedByToStrim(xout);
  }
}