text:
#ifndef GUI_PROT_MESSAGES_H
#define GUI_PROT_MESSAGES_H

#include "GuiProt/Serializable.h"
#include "GuiProt/GuiProtEnums.h"
#include "GuiProt/Favorite.h"
#include "TopRegion.h"
#include "Nav2Error.h"
#include "RouteInfo.h"
#include "GuiProt/ServerEnums.h"
#include "HintNode.h"
/* #include "GpsSatelliteInfo.h" */
#include <vector>

//More includes at end of file.

#ifndef __SYMBIAN32__
   using namespace std;
#endif

namespace isab {

   namespace GuiProtEnums {
      class ParameterTypeHolder;
   }

/**
  *   GuiProtMess is superclass to all GUI protocol message
  *   classes. Gui protocol message classes are used for
  *   GuiProtEnums::MessageType:s with GuiProtEnums::DataType
  *   type_and_data.
  *
  */
class GuiProtMess : public Serializable
{

   public:

      /**
       * This id is assigned to m_id by default as
       * place holder. Until sync has been obtained,
       * this id is unchanged in the messages.
       */
      static const uint16 NO_SYNC_MESS_ID;

      /**
       * The GUI protocol used by the PDA ThinClient.
       */
      static const uint8 THIN_CLIENT_GUI_PROT_NBR;

      /**
       * The GUI protocol used now.
       */
      static const uint8 CURRENT_GUI_PROT_NBR;

      /** Constructor.*/
      GuiProtMess(class Buffer* buf);

      GuiProtMess(GuiProtEnums::DataType dataType, GuiProtEnums::MessageType messType);

      GuiProtMess(GuiProtEnums::MessageType messType);

      /** Destructor. */
      virtual ~GuiProtMess();

      static GuiProtMess* createMsgFromBuf(class Buffer* buf);

      /** Serializable interface methods. */
      //@{
         /**
          * Writes this message to a buffer, which can be used
          * when sending the message. (Make sure the id is set).
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serialize(class Buffer* buf) const;
      //@}

      /** Abstract methods. */
      //@{
         /**
          * This method is called in order to serialize the
          * data of the message.
          *
          * @param buf The buffer to write the data to.
          */
         virtual void serializeMessData(class Buffer* buf) const = 0;

         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers() = 0;
      //@}

      /** Get methods. */
      //@{
         GuiProtEnums::DataType    getMessageDataType() const;
         GuiProtEnums::MessageType getMessageType() const;
         uint16                    getMessageID() const;
      //@}

      /**
       * Use this method to set the id of the message, which is
       * used for sync. Set the id right before sending the
       * message to make sure that the number serie is not broken.
       *
       * @param id The id of this message. When sync has been
       *           reached, this id should be incremented with
       *           1 for each message sent.
       */
      void setMessageId(uint16 id);

   protected:
      /**
       * Member variables.
       */
      //@{
         GuiProtEnums::DataType m_dataType;
         GuiProtEnums::MessageType m_messageType;
         uint16 m_ID;
      //@}

      /**
       * Protected methods.
       */
      //@{

      //@}

}; // GuiProtMess

/**
  *   A class for messages with simple data, i.e. all messages
  *   that have a data type other than type_and_data.
  *
  */
class GenericGuiMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      GenericGuiMess(class Buffer* buf);

      /**
       * Copy constructor.
       */
      explicit GenericGuiMess( const GenericGuiMess* o );

      /**
       * Different generic messages.
       *
       * Only the data given in the constructor is set in the
       * message. Use this class for messages with simple data.
       */
      explicit GenericGuiMess(GuiProtEnums::MessageType messType);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     bool firstBool);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     bool firstBool, bool secondBool);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     bool firstBool, bool secondBool, bool thirdBool);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     const char* firstString);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     const char* firstString, const char* secondString);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     const char* firstString, const char* secondString,
                              const char* thirdString);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     uint8 firstUint8);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     uint8 firstUint8, uint8 secondUint8);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     uint16 firstUint16);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     uint16 firstUint16, uint16 secondUint16);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     int64 firstInt64);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     uint32 firstUint32);

      explicit GenericGuiMess(GuiProtEnums::MessageType messType,
                     uint32 firstUint32, uint32 secondUint32);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       *
      GenericGuiMess(data);
       */

      /** Destructor. */
      virtual ~GenericGuiMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();

          /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
        * Get methods for different members. Check the getMessageType
        * to determine which members that are valid.
        */
      //@{
         uint8 getFirstUint8() const;
         uint8 getSecondUint8() const;
         uint16 getFirstUint16() const;
         uint16 getSecondUint16() const;
         uint32 getFirstUint32() const;
         uint32 getSecondUint32() const;
         char* getFirstString() const;
         char* getSecondString() const;
         char* getThirdString() const;
         bool getFirstBool() const;
         bool getSecondBool() const;
         bool getThirdBool() const;
         int64 getFirstInt64() const;
      //@}

   protected:
      /**
       * Member variables.
       */
      //@{
         /**
          * m_firstUint8 stores both uint8 values
          * and bool values.
          */
         uint8 m_firstUint8;
         uint8 m_secondUint8;
         uint8 m_thirdUint8;
         uint16 m_firstUint16;
         uint16 m_secondUint16;
         uint32 m_firstUint32;
         uint32 m_secondUint32;
         int64 m_firstInt64;
         char* m_firstString;
         char* m_secondString;
      //@}

      /**
       * Protected methods.
       */
      //@{
         void initMembers();
      //@}

}; // GenericGuiMess

/**
  *   ErrorMess description.
  *
  */
class ErrorMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      ErrorMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param errorNbr The error number of the error.
       * @param errorString The error string of the error.
       * @param errorURL The URL for the error, to be opened in content
       *                 window if not empty and we have content window.
       */
      ErrorMess( Nav2Error::ErrorNbr errorNbr,
                 const char* errorString,
                 const char* errorURL );

      /** Destructor. */
      virtual ~ErrorMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();

         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the error string explaining this error in the
       * choosen language. This string must be deleted
       * by the caller.
       *
       * @return A string, which describes the error in the
       *         choosen language.
       */
      char* getErrorString() const;

      /**
       * Returns the error URL. May be empty if so no need to open the
       * URL.
       *
       * @return An URL which to be opened in content window.
       */
      const char* getErrorURL() const;

      /**
       * @return Returns a number uniquely identifying the
       *         error usign Nav2 error numbers.
       */
      Nav2Error::ErrorNbr getErrorNumber() const;

   protected:
      /**
       * Member variables.
       */
      //@{
         /**
          * Identyfies the error uniquely using Nav2 error
          * codes.
          */
         Nav2Error::ErrorNbr m_errorNbr;

         /**
          * Describes the error in the used language.
          */
         char* m_errorString;

         /**
          * The error URl, mey be empty.
          */
         char* m_errorURL;
      //@}

}; // ErrorMess

/**
  *   RequestFailedMess description.
  *
  */
class RequestFailedMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      RequestFailedMess(class Buffer* buf);

      /**
       * Use one of these constructors to create a message to send.
       *
       * @param errorNbr The error number of the error causing the
       *                 request to fail.
       *
       * @param errorString The error string of the error causing
       *                    the request to fail.
       *
       * @param errorURL The URL for the error, to be opened in content
       *                 window if not empty and we have content window.
       * @param failedRequestSeqId The sequence id got from the GUI
       *                           on the request that failed.
       * @param failedRequestMessageNbr The message number on the
       *                                 request that failed.
       * @param failedRequestString The "request failed" message,
       *                            telling the user what happened.
       */
      //@{
         RequestFailedMess(Nav2Error::ErrorNbr errorNbr,
                           const char* errorString,
                           const char* errorURL,
                           uint16 failedRequestSeqId,
                           GuiProtEnums::MessageType failedRequestMessageNbr,
                           const char* failedRequestString);

      //@}

      /** Destructor. */
      virtual ~RequestFailedMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       */
      //@{
         /**
          * Information on the error causing the request to
          * fail.
          */
         //@{
            uint32 getErrorNbr() const;
            char*  getErrorString() const;

            /**
             * Returns the error URL. May be empty if so no need to open
             * the URL.
             *
             * @return An URL which to be opened in content window.
             */
            const char* getErrorURL() const;
         //@}

         /**
          * Information on the request that failed.
          */
         //@{
            /**
             * @return The message sequence id for the message
             *         that the request arrived to Nav2 in.
             *
             *         NB! This one is always 0 for
             *             ThinClient GUI protocol messages.
             */
            uint32 getFailedRequestSeqId() const;

            /**
             * @return Either a GuiProtEnums::MessageType or
             *         NavCtrlGuiProt::PacketNumber_t depending
             *         on what GUI protocol that was used when
             *         initiating the request.
             *
             *         These numbers never mix.
             *
             *         NavCtrlGuiProt::PacketNumber_t is the same
             *         as ThinClientGuiProtEnums::PacketNumber_t
             */
            uint8  getFailedRequestMessageNbr() const;
            /**
             * @return The "request failed" message, telling the user
             *         what happened.
             */
            char*  getFailedRequestString() const;
         //@}
      //@}

   protected:
      /**
       * Member variables.
       */
      //@{
         Nav2Error::ErrorNbr m_errorNbr;
         char*               m_errorString;
         char*               m_errorURL;

         uint16 m_failedRequestSeqId;
         uint8  m_failedRequestMessageNbr;
         char*  m_failedRequestString;

      //@}

      /**
       * Protected methods.
       */
      //@{
         /**
          * Used by the constructor.
          */
         void initMembers(Nav2Error::ErrorNbr errorNbr,
                          const char* errorString,
                          const char* errorURL,
                          uint16 failedRequestSeqId,
                          uint8 failedRequestMessageNbr,
                          const char* failedRequestString);
      //@}

}; // RequestFailedMess

class UpdatePositionMess : public GuiProtMess
{
public:
   UpdatePositionMess(class Buffer* buf);
   UpdatePositionMess(int32 lat, int32 lon,
                      int32 routelat, int32 routelon,
                      uint8 positionQuality,
                      uint8 heading, uint8 routeheading,
                      uint8 headingQuality,
                      uint16 speed, uint8 speedQuality,
                      int32 alt,
                      uint32 timeStampMillis,
                      const std::vector<HintNode>& hintNodes );
   virtual ~UpdatePositionMess();
   virtual void deleteMembers();
   virtual void serializeMessData(class Buffer* buf) const;

   int32 getLat() const;
   int32 getLon() const;
   // Contains the best positon on the route for the snap to route function.
   int32 getRouteLat() const;
   int32 getRouteLon() const;
   uint8 getRouteHeading() const;
   uint8 positionQuality() const;
   uint8 getHeading() const;
   uint8 headingQuality() const;
   uint16 getSpeed() const;
   uint8 speedQuality() const;
   int32 getAlt() const;
   uint32 getTimeStampMillis() const;
   const std::vector<HintNode>& getInterpolationHints() const;
private:
   int32 m_lat;
   int32 m_lon;

   // Contains the best positon on the route for the snap to route function.
   int32 m_routelat;
   int32 m_routelon;

   uint8 m_positionQuality; //enum?
   uint8 m_heading;
   uint8 m_routeheading;
   uint8 m_headingQuality; //enum?
   uint16 m_speed;
   uint8 m_speedQuality;
   int32 m_alt;
   uint32 m_timeStampMillis;
   std::vector<HintNode> m_positionHints;
};

/**
  *   GetTopRegionReplyMess description.
  *
  */
class GetTopRegionReplyMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      GetTopRegionReplyMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param topRegionList The data is not deleted in the message
       *                      destructor. This top region list is not
       *                      deleted by the message destructor.
       *
       */
      GetTopRegionReplyMess(TopRegionList* topRegionList);

      /** Destructor. */
      virtual ~GetTopRegionReplyMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();

         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return A top region list. The checksum member of it
       *         should not be used by the GUI. This list may
       *         be empty.
       */
      TopRegionList* getTopRegionList() const;

   protected:
      /**
       * Member variables.
       */
      //@{
         TopRegionList* m_topRegionList;
      //@}

}; // GetTopRegionReplyMess

/**
  *   GeneralParameterMess description.
  *
  */
class GeneralParameterMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      explicit GeneralParameterMess(class Buffer* buf);

      /**
       * Use one of these constructors to create a message to send.
       *
       *        The data is not deleted in the message
       *        destructor.
       */
      /* Constructor used to create a "get" message. */
      explicit GeneralParameterMess(uint16 paramId);
      /* Convenience constructors with only one value as input. */
      /** NOTE! These methods will allocate space for and copy data, */
      /** so it is necessary to perform deleteMembers()!!! */
      GeneralParameterMess(uint16 paramId, int32 data);
      GeneralParameterMess(uint16 paramId, float data);
      GeneralParameterMess(uint16 paramId, char* data);
      /* More general constructors that take any number of values */
      /* as input. */
      GeneralParameterMess(uint16 paramId, int32* data, int32 numEntries);
      GeneralParameterMess(uint16 paramId, float* data, int32 numEntries);
      GeneralParameterMess(uint16 paramId, uint8* data, int32 numEntries);
      GeneralParameterMess(uint16 paramId, char** data, int32 numEntries);

      /** Destructor. */
      virtual ~GeneralParameterMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return     Address of the data.
       */
       char**   getStringData() const;
       uint8*  getBinaryData() const;
       float*  getFloatData() const;
       int32* getIntegerData() const;

       uint16 getParamId() const;
       int32 getNumEntries() const;
       uint16 getParamType() const;

   protected:
       void initData();
      /**
       * Member variables.
       */
      //@{
          char** m_stringData;
          uint8* m_binaryData;
          float* m_floatData;
          int32* m_integerData;

          uint16 m_type;
          uint16 m_paramId;
          int32 m_numEntries;
      //@}

}; // GeneralParameterMess

class UpdateRouteInfoMess : public GuiProtMess
{
   public:
      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      UpdateRouteInfoMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      UpdateRouteInfoMess(const RouteInfo* info);

      /** Destructor. */
      virtual ~UpdateRouteInfoMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
   const RouteInfo* getRouteInfo() const;
   protected:
      /**
       * Member variables.
       */
      //@{
   /// A routeinfo object containing everything a guideview could ever
   /// hope for..
   const RouteInfo* m_routeInfo;
      //@}

}; // UpdateRouteInfoMess

class SatelliteInfoMess : public GuiProtMess
{
   public:
      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      SatelliteInfoMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      SatelliteInfoMess(class GpsSatInfoHolder* info);

      /** Destructor. */
      virtual ~SatelliteInfoMess();

      /** GuiProtMess interface methods. */
      //@{
      /**
       * When calling this method, all members of the message
       * is deleted. I.e. if this method is not called, all
       * the message members must be taken out of the message
       * and be deleted.
       */
      virtual void deleteMembers();
      /**
       * Writes the data of this message to a buffer.
       *
       * @param buf The buffer to write the message to.
       */
      virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
      class GpsSatInfoHolder* getSatInfo();
   protected:
      /**
       * Member variables.
       */
      //@{
      /// A routeinfo object containing everything a guideview could ever
      /// hope for..
      class GpsSatInfoHolder* m_satInfo;
      //@}

}; // SatelliteInfoMess

class RouteListMess : public GuiProtMess
{
   public:
      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      RouteListMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      RouteListMess(const RouteList* list);

      /** Destructor. */
      virtual ~RouteListMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
   const RouteList* getRouteList() const;
   protected:
      /**
       * Member variables.
       */
      //@{
   /// A routeinfo object containing everything a guideview could ever
   /// hope for..
   const RouteList* m_routeList;
      //@}

}; // RouteListMess

class GetFilteredRouteListMess : public GuiProtMess
{
   public:
      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      GetFilteredRouteListMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      GetFilteredRouteListMess(int16 startWpt, int16 numWpts);

      /** Destructor. */
      virtual ~GetFilteredRouteListMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
   const int16 getStartWpt() const { return m_startWpt; }
   const int16 getNumWpts() const  { return m_numWpts;  }
   protected:
      /**
       * Member variables.
       */
      //@{
      int16 m_startWpt;
      int16 m_numWpts;
      //@}

}; // UpdateRouteInfoMess

class PrepareSoundsMess : public GuiProtMess
{
   public:
      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      PrepareSoundsMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      PrepareSoundsMess(int numSounds, const int sounds[]);

      /** Destructor. */
      virtual ~PrepareSoundsMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
   const int * getSounds() const;
   int getNumSounds() const;
   protected:
      /**
       * Member variables.
       */
      //@{
   const int *m_soundList;
   int m_numSounds;
      //@}

}; // PrepareSoundsMess

/**
  *   SoundFileListMess description.
  *
  */
class SoundFileListMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      explicit SoundFileListMess(Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       *        The data is not deleted in the message
       *        destructor.
       */
      SoundFileListMess(char** data, int32 numEntries);

      /** Destructor. */
      virtual ~SoundFileListMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return     Address of the data.
       */
       char**   getStringData() const;

       int32 getNumEntries() const;

   protected:
       void initData();
      /**
       * Member variables.
       */
      //@{
          char** m_stringData;
          int32 m_numEntries;
      //@}

}; // SoundFileListMess

class SendMessageMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      SendMessageMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      SendMessageMess(enum GuiProtEnums::UserMessageType messT,
                      enum GuiProtEnums::ObjectType objT, char* id, char* from,
                      char* to, char* sig);

      /** Destructor. */
      virtual ~SendMessageMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
   GuiProtEnums::UserMessageType getMedia() const ;
   GuiProtEnums::ObjectType getObject() const;
   char* getId() const;
   char* getFrom() const;
   char* getTo() const;
   char* getSignature() const;

   protected:
      /**
       * Member variables.
       */
      //@{
   GuiProtEnums::UserMessageType m_media;
   GuiProtEnums::ObjectType m_object;
   char* m_id;
   char* m_from;
   char* m_to;
   char* m_sig;
      //@}

}; // SendMessageMess

class MessageSentMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      MessageSentMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       */
      MessageSentMess(uint8* data, unsigned len);

      /** Destructor. */
      virtual ~MessageSentMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       */
   unsigned size() const;
   uint8* getData(unsigned*size=NULL) const;

   protected:
      /**
       * Member variables.
       */
      //@{
   uint8* m_data;
   unsigned m_len;
      //@}

}; // MessageSentMess

class LicenseKeyMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      LicenseKeyMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       *
       */
      LicenseKeyMess(const char* key, const char* phone, uint32 region);

      LicenseKeyMess(const char* key, const char* phone,
                     const char* name, const char* email,
                     const char* optional,
                     uint32 region);

      /** Destructor. */
      virtual ~LicenseKeyMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       *
       */
   const char* getKey() const;
   const char* getPhone() const;
   const char* getName() const;
   const char* getEmail() const;
   const char* getOptional() const;
   uint32 getRegion() const;

   protected:
      /**
       * Member variables.
       */
      //@{
   char* m_key;
   char* m_phone;
   char* m_name;
   char* m_email;
   char* m_optional;
   uint32 m_region;
      //@}

}; // LicenseKeyMess

/**
  *   LicenseReplyMess description.
  *
  */
class LicenseReplyMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      LicenseReplyMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       *
       * @param data The data is not deleted in the message
       *             destructor.
       *
       */
      LicenseReplyMess(bool keyOk, bool phoneOk, bool regionOk,
                       bool nameOk, bool emailOk,
                       GuiProtEnums::WayfinderType type);

      /** Destructor. */
      virtual ~LicenseReplyMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}

      /**
       * Returns the data of message. This data is not deleted
       * by the message destructor.
       *
       * @return
       *
       */
   bool isKeyOk() const;
   bool isPhoneOk() const;
   bool isRegionOk() const;
   bool isNameOk() const;
   bool isEmailOk() const;
   bool allOk() const;
   GuiProtEnums::WayfinderType getWayfinderType() const;

   protected:
      /**
       * Member variables.
       */
      //@{

   bool m_keyOk;
   bool m_phoneOk;
   bool m_regionOk;
   bool m_nameOk;
   bool m_emailOk;
   GuiProtEnums::WayfinderType m_type;
      //@}

}; // LicenseReplyMess

/**
  *   DataGuiMess is a representation of any message that consists of a
  *   32 length field followed by binary data.
  *   The message content type is always set to type_and_length_and_data.
  *
  */
class DataGuiMess : public GuiProtMess
{
   public:

      /**
       * Use this constructor to reconstruct the message from
       * a buffer.
       *
       * @param buf A buffer which contains this message at the
       *            read position. This position is moved to
       *            the beginning of next message.
       */
      DataGuiMess(class Buffer* buf);

      /**
       * Use this constructor to create a message to send.
       * @param messType The message type.
       * @param size the size of the data field.
       * @param data the binary data block to include in the message.
       *             The data is copied into the object.
       *             The data is not deleted in the message
       *             destructor, use deleteMembers instead.
       * @param ad_size the size of the additional data field.
       * @param ad_data the additional binary data block.
       *
       */
      DataGuiMess(GuiProtEnums::MessageType messType,
                  uint32 size, const uint8* data,
                  uint32 ad_size = 0, const uint8* ad_data = NULL,
                  uint8 requestVer = 1 );

      /** Destructor. */
      virtual ~DataGuiMess();

      /** GuiProtMess interface methods. */
      //@{
         /**
          * When calling this method, all members of the message
          * is deleted. I.e. if this method is not called, all
          * the message members must be taken out of the message
          * and be deleted.
          */
         virtual void deleteMembers();
         /**
          * Writes the data of this message to a buffer.
          *
          * @param buf The buffer to write the message to.
          */
         virtual void serializeMessData(class Buffer* buf) const;
      //@}
   /** Returns the size of the data block, size field is not included
    * in this size.
    * @return the data block size.
    */
   uint32 getSize() const;

   /** Returns the size of the additional data block,
    * @return the additional data block size.
    */
   uint32 getAdditionalSize() const;

   /**
    * Returns the data of message. This data is not deleted by the
    * message destructor, use deleteMembers if you want that to
    * happen.
    *
    * @param length pointer to a length variable. If the pointer is
    *               non-null the size of the data block will be written
    *               through the pointer.
    * @return a pointer to the start of the data block.
    */
   const uint8* getData(uint32* length = NULL) const;

   const uint8* getAdditionalData(uint32* length = NULL) const;

   uint8 getRequestVersion() const;

   protected:
      /**
       * Protected member variables.
       */
      //@{
   /** Holds the size of the data block.*/
   uint32 m_size;
   /** Pointer to the data block.*/
   uint8* m_data;
   /** Holds the size of the additional data block.*/
   uint32 m_ad_size;
   /** Pointer to the additional data block.*/
   uint8* m_ad_data;
   /** The protocol version of the request.*/
   uint8 m_requestVer;
      //@}

}; // DataGuiMess

} // namespace isab

#endif // GUI_PROT_MESSAGES_H

redpajama_set_name: RedPajamaGithub


This fun towel features a fun flamingo with a name embroidered horizontally in an all lowercase font. Default color for design is hot pink/orange.
Towels are very cute! Seller makes sure you are happy with the design before processing.
Bridesmaid gifts were sooo cute & perfect! They arrived earlier than expected , even though they were customized with names! Couldn't be happier, everyone loved them!!!!!
Cute towel, great customer service!


Oh, yes.  Maybe we need to go back to deprecated?
> Is there any conflict between the current discussion of obsoleting and the previous usage of the term in W3C.  As one random example, HTML 4.01 in its Status says that it obsoletes HTML 4 .
Next message: Chris Wilson: "Re: Obsoleting"
Next in thread: Chris Wilson: "Re: Obsoleting"
Reply: Chris Wilson: "Re: Obsoleting"
Reply: Chaals McCathie Nevile: "Re: Obsoleting"


text:
Q: How can I tell if a SelectionChanged event was a result of UI interaction or programmatic change in the ViewModel in WPF? I have a ListBox with a two way binding from my View Model to SelectedItem. When the View Model is updated, SelectedItem is updated and the SelectionChanged event is fired. SelectionChanged is also fired through direct user interaction in the UI e.g. clicking with mouse, touch selection, keyboard input.
I would like to perform a certain action in SelectionChanged only if the change came from UI interaction.
There appears to be properties in SelectionChangedEventArgs that cater to this (e.g. OriginalSource and UserInitiated) but they are not different between the two cases.
Is distinguishing between the two possible?

A: You can use SourceUpdated and TargetUpdated events. If you set Binding's NotifyOnSourceUpdated and NotifyOnTargetUpdated properties to True, then you can handle those events to distinguish the source of the change:
<ListBox ItemsSource="{Binding TestCollection}"
        SelectedItem="{Binding TestSelection, Mode=TwoWay, NotifyOnSourceUpdated=True, NotifyOnTargetUpdated=True}"
        SourceUpdated="ListBox_SourceUpdated" TargetUpdated="ListBox_TargetUpdated"
        SelectionChanged="ListBox_SelectionChanged" />

Those events are called before SelectionChanged so you either can take action in their handlers or set some flag to use in SelectionChanged or whatever.

redpajama_set_name: RedPajamaStackExchange


text:
News Blogs Developments Jobs Tenders Leads Events
Aloft Hotel tops out at new AECC site
Published 3 September 2018
The 150-bedroom Aloft Hotel, part of the new AECC project which includes The Event Complex Aberdeen (TECA), has "topped out" now that the structure has been completed.
The hotel, located just north of the Hilton Hotel that adjoins TECA, will be the first building in Phase 2 of the AECC masterplan at Bucksburn.
The multi-million pound project, which is being delivered by Aberdeen City Council and its development partner Henry Boot Developments (HBD), is being constructed by Robertson Group and will provide a new world-class facility for Scotland. The 12,500-capacity arena along with conference and exhibition spaces will host major events and music concerts.
The new facility is expected to contribute an additional 4.5 million visitors, £113 million of visitor spend and £63m net Gross Value Added to the Scottish economy. It will also result in the creation of 352 full-time-equivalent permanent positions by year 10 of operations.
Nick Harris, director of HBD in Scotland, said: "The Aloft Hotel is a key part of this flagship project for Aberdeen and the north east. This is the last of the buildings under construction to 'top out', and we are now moving to the interior fit-out stage. The installation of the interiors has already begun at TECA itself and at the adjoining Hilton hotel, so we're entering another really exciting phase of the project where we will see the buildings really start to come to life."
Aberdeen City Council co-leader, Councillor Douglas Lumsden, said: "It is fantastic that another milestone has been achieved in what is one of the most significant developments for Aberdeen.
"The Aloft hotel is a new brand for Aberdeen and fits with the aims of our Regional Economic Strategy which has internationalisation at its heart. The build of the entire site is continuing at great pace and we're looking forward to watching it progress in the remaining months."
Robertson Group's chief executive officer, Derek Shewan, said: "There has been significant investment in Aberdeen in recent times and TECA is a major part of this. Venues such as this support the increased focus on travel and tourism in the area. As a company with its roots right here in the North East we're proud of the role we've played in making this development become a reality.
"To see all the major building exteriors within the complex complete is a significant milestone and a testament to the Robertson team's work and project management."
Designed by architects Cooper Cromar, with interiors by Twenty2Degrees, the new Aloft Hotel will be the first of its kind in Scotland. Both the Aloft and Hilton hotel will be managed by hotel management company RBH.
Andrew Robb, chief business development officer for RBH, said: "It's wonderful to see the Aloft structure completed – it represents a significant milestone in the journey towards opening the doors to our first guests in 2019, and is a major step forward in the AECC project as a whole. As an Aberdonian myself I am excited to see investment of this scale in the city and the benefits which this will bring to the wider community.
"This new hotel will see a second Aloft property join our growing portfolio, alongside Aloft Liverpool, and is representative of an increasingly strong partnership with brand owner Marriott. We look forward to bringing Aloft's quality accommodation and food and beverage offering to the city with the opening of this contemporary hotel."
Tags: Aberdeen, AECC/TECA, Cooper Cromar, Henry Boot, Robertson Group
Sigma Capital expands Edinburgh team to support PRS offering Encouraging performance from Scottish office market despite political uncertainty Aberdeen affordable homes plan recommended for refusal
Latest Jobs & Tenders
Project Manager - ng homes SVQ Assessor Painting & Decorating – Glasgow Clyde College SVQ Assessor Carpentry & Joinery – Glasgow Clyde College Technical Advisor - SNIPEF Send your jobs and tenders to Scottish Construction Now
Latest Leads
Construction leads - January 17th Construction leads - January 16th Construction leads - January 15th
Workshop for island solutions for circular construction and infrastructure - Zero Waste Scotland
© Dundee Press Agency Ltd 2020
Website built by Connor Beaton

redpajama_set_name: RedPajamaCommonCrawl


text:
President of Chechnya Intends to Eliminate All Gay Men There by Ramadan
April 23, 2017 by Luis Damian Veron Leave a Comment
The British Foreign Office has confirmed threats by Chechen president Ramzan Kadyrov that he intends to eliminate all gay men in the republic by Ramadan, which begins May 26.
In a speech to parliament this past Wednesday, the deputy foreign secretary of the United Kingdom decried the ongoing reports of the rounding up, torture and persecution of gay men in the Muslim-majority Russian territory in the Caucasus, and made the alarming revelation of the threat:
Sir Alan Duncan, Minister of State for Foreign and Commonwealth Affairs, told parliament: "Human rights groups report that these anti-gay campaigns and killings are orchestrated by the head of the Chechen republic, Ramzan Kadyrov. He has carried out other violent campaigns in the past, and this time he is directing his efforts at the LGBT community.
Sources [in local Russian media] have said that he wants the [LGBT] community eliminated by the start of Ramadan."
Kadyrov has continued to deny accounts of any anti-gay campaign, including in a meeting with Russian president Vladimir Putin, who unsurprisingly has shown no inclination to address the situation. Human Rights Watch and other human rights organizations, however, have documented the disturbing developments on the ground since local newspaper Novaya Gazeta first called attention to them earlier this month, including dozens of detentions and several executions:
Chechnya is a highly traditional Muslim society, and for many not only is homosexuality unacceptable but having a relative who might be gay represents an unspeakable "stain" on their family's honor and reputation. During the recent campaign, police have leveraged this social stigma by, in many cases, releasing men suspected to be gay to their families and "outing" them. They encourage families to "restore family honor," which in Chechen terms usually means through an "honor" killing. At least three men have died since the campaign started at the end of February.
News of the purge has continued to draw concern and criticism abroad, from foreign governments as well as LGBTQ activists, who in Canada have called for emergency visas to be issued, and the urgency of the situation now seems more apparent than ever.
Filed Under: Uncategorized Tagged With: Chechnya, International LGBT Rights, Russia, United Kingdom, Vladimir Putin
Previous Post: « Tom Daley and Dustin Lance Black Have Romantic Deja Vu in Paris: WATCH
Next Post: New 'Google Home' Ad Features Gay Dads: WATCH »


text:
The "French Henry Ford" Born
On this day in 1878, Andre Citroen, later referred to as the Henry Ford of France for developing his country's first mass-produced automobiles, is born in Paris. Citroen revolutionized the European auto industry by making vehicles that were affordable to average citizens.
Before entering the auto business, Citroen studied engineering and later operated a gear manufacturing company. During World War I, he ran a munitions factory where he successfully implemented mass-production technology. Following the war, Citroen, who was inspired by the assembly-line innovations at Henry Ford's American auto plants, converted his munitions factory into a facility to make low-cost vehicles. At the time, only the wealthy in Europe had been able to afford automobiles. Citroen's first car, the Type A, debuted in 1919. The four-door, 10-horsepower vehicle featured an electric starter, lights and a spare tire and was capable of speeds of 40 mph. The Type A was a success, due in part to Citroen's talent as an innovative marketer. He allowed potential customers to take his vehicles for a test drive—then a new concept—and also let people buy on credit. He put the Citroen name in lights on the Eiffel Tower, launched skywriting ads to promote his products and masterminded attention-getting expeditions to Africa and Asia using Citroen vehicles.
In 1934, Citroen launched the Traction Avant, the first mass-produced passenger car to feature front-wheel drive. The car proved enormously popular, and more than 750,000 were built during the 23-year production run. At the time of the Traction Avant's release, however, the Citroen company was on the verge of bankruptcy due to Andre Citroen's heavy investments in new concepts and technology, as well as his alleged gambling debts. In 1935, Citroen was taken over by its largest creditor, the Michelin Tire Company. Andre Citroen, who had been forced out of the business he founded, became ill and died on July 3, 1935.
Citroen remained part of Michelin until the 1970s, when it was sold to the French automaker Peugeot. Today, Peugeot Citroen is one of Europe's leading auto manufacturers.
Posted in Automotive.
← Wimbledon Tournament Begins
HMS Pinafore Premieres In London →


text:
Stigmella maya is a moth of the family Nepticulidae. It is found on the Yucatán Peninsula of southeastern Mexico.

This species is among the smallest Lepidoptera in the world.

The larvae feed on Karwinskia humboldtiana. They mine the leaves of their host plant.

References

Moths described in 2013
Nepticulidae
Moths of Central America

redpajama_set_name: RedPajamaWikipedia


Perform and master the DJing skills like a pro with the most basic DJ controller, introducing the Pioneer DDJ-400. The DDJ-400 is USB powered and no drivers are needed, just plug into your laptop and play.
Pioneer DJ has improved their DJ controller from time to time. With the new DJ controller, you can learn the basics by using the new interactive Tutorial feature in rekordbox dj, including the track selection assistant, to quickly grasp everything easily.
There's always a saying, practice makes perfect. Develop your skills, get creative and spice up your sets with Beat FX, CDJ-style looping controls and more features for you to explore on the DDJ-400.
There's no need to worry or confused when using the controller as the club-style layout inherits its design from the professional NXS2 set-up. Easily record your sets in rekordbox and share them on social media. Track titles and time stamps are added automatically.
The lightweight DJ controller portable design comes with grab handles makes carrying easy and suitable to take it anywhere for gigs or parties.


text:
Q: (Tikz) graphics: series of pictures _outside_ beamer-style frames and overlays? I want to create a series of related graphs, for instance, higlighting the traversal through a graph. It works nice using overlays in beamer frames.
Can I do analogous things in a normal document? Of course not an "overlay", but
side-by-side pictures where the first gives the only<1>-part of the figure as shown in the presentation, the second the only<2>-part etc.
Martin

A: probably like this?
Code
\documentclass[parskip]{scrartcl}
\usepackage[margin=15mm]{geometry}
\usepackage{tikz}
\usepackage{xifthen}

\newcommand{\layerpic}[2]% layers, commands
{   \foreach \x in {1,...,#1}
    {   \begin{tikzpicture}
            \pgfmathtruncatemacro{\i}{\x+1}
            #2
        \end{tikzpicture}\\[1cm]
    }
}

\newcommand{\mylayer}[2]% layer, layer commands
{   \ifthenelse{\i>#1}
        {#2}
        {}
}

\begin{document}

\layerpic{4}
{   \mylayer{1}
    {   \fill[green!50!gray] (0,0) rectangle (12,4);
    }
    \mylayer{2}
    {   \fill[red!50!gray] (6,2) ellipse (5.5 and 1.5);
    }
    \mylayer{3}
    {   \fill[blue!50!gray] (1,1) circle (0.5);
        \fill[blue!50!gray] (11,1) circle (0.5);
        \fill[blue!50!gray] (1,3) circle (0.5);
        \fill[blue!50!gray] (11,3) circle (0.5);
    }
    \mylayer{4}
    {   \fill[yellow!50!gray] (3,0.1) --  (6,3.9) -- (9,0.1) -- cycle;
    }
}

\end{document}

Result

Edit 1: Here's a command that will act differently in beamer and non-beamer documents:
Code
\makeatletter
\@ifclassloaded{beamer}
  {\xdef\isbeamer{1}}
  {\xdef\isbeamer{0}}%
\makeatother

\newcommand{\layerpic}[2]% layers, commands
{ \ifthenelse{\isbeamer=1}
    {   \begin{tikzpicture}[scale=0.5]
            #2
        \end{tikzpicture}
    }
    {   \foreach \x in {1,...,#1}
    {   \begin{tikzpicture}
        \pgfmathtruncatemacro{\i}{\x+1}
        #2
        \end{tikzpicture}\\[1cm]
    }
  }
}

\newcommand{\mylayer}[2]% layer, layer commands
{ \ifthenelse{\isbeamer=1}
    {   \only<#1->{#2}
    }
    {   \ifthenelse{\i>#1}
    {#2}
    {}
  }
}

Output
In a non-beamer document (e.g. scrartcl), the output is exactly the same as before. In beamer however (the tikzpicture is scaled to 0.5 in beamer mode, as slides are only 128mm wide):


The "Starter kit" contains everything you need to start making single and double-sided PCBs in just a few minutes. Contains: Toner Transfer Paper, Copper Laminate Board and TRF Sealing Foils.
With either Starter kit and the recommended Tamerica "SM-330" laminator or a household iron (that has been calibrated. See TECH SUPPORT > Instructions > Using An Iron), you will have the ability to make high density, high quality single and double-sided PCBs, first time - every time, in about 8 minutes. Plus you can even do it WITHOUT using an etching tank! (We developed this unique technique a few years back that you've got to try to believe! See the MENU item: TECH SUPPORT > No Etching Tank).
The Mini-Kit has 1 package of Toner Transfer Paper, 2ea 4-Board Packs of 6"x8" boards w/scrubbing pad (S/S + D/S) and one GreenTRF pack.
The "PCB Fab-In-A-Box" kit comprises 3 basic "components". All items are available separately so when a particular supply runs low, you can always reorder it separately.
The first step in our process is to get your PCB design out of the printer via a special transfer medium coated with a special water-relase agent for perfect transfers when subjected to heat & pressure (from the laminator above).
Our high-quality laminate boards are made in the USA (Conneticut, OH) by skilled lamination experts. They are custom made for us using 1/2oz copper foil on a built-up .032" thick fiberglass FR4/G-10 base.
The GreenTRF foil is fused over the transferred circuit image on the board to seal the toner from "etch through".
The WhiteTRF is optional for a parts insertion "silk-screen" layer.
Also included in the "Starter Kit" is a special custom printed page of circuit test images on a sheet of Toner Transfer Paper used for trouble-shooting if your printed images aren't transferring properly. Used as a reference to compare the quality of your printouts.
This page of test circuit images is printed using a new "branded" toner cartridge for guaranteed known density of toner to make perfect transfers. For optimum performance, you never want to use an "after-market" toner cartridge. They are just inferrior to "branded" cartridges. Having good toner density is most important for proper transfers to the copper's surface. If you find your are having transfer problems, that's when you'd use one of these images. It will immediately point to the source of the problem... either your laser printer is not putting out enough toner density or the TIA laminator is not working properly.
<-Click the image here to see the incredible level of detail you will be able to achieve when using a laminator as the heat/pressure device. When using a household iron, you will be limited to about .015" trace widths.
As with all of the products we produce, you have a full month to "kick the tires" after you recieve your system. If at any time you aren't absolutely in love with what our process can do for you, we'll buy it back at full price... even used, and no silly restocking fees, or discounting your refund. "If you don't love it, we want it back!"
If you encounter any problems with any of our products, give us a call and let us trouble-shoot your situation. Tech Support from us is unending. Call us anytime! We're open 9am to 5pm MST.


Joe Rios works at Export Development Canada (EDC) as a Marketing Leader enabling Canadian exporters to grow internationally. In his spare time, he's a fitness instructor and an ultra-marathoner. Running for a cause is part of his DNA.
His fitness journey started in 2009 when he went from couch potato/smoker to running his first half-marathon for Team Diabetes. The challenges continued and in 2015 Joe completed a marathon on all 7 continents, including a 50k ultra-marathon in Antarctica, while raising $100,000 for a variety of charities.
His biggest passion is helping others find a way to do good while challenging themselves with their running goals. One way he does this is by volunteering with an organization called Impact Marathon – a social business designed to bring people together to harness the power of running marathons and sustainably build communities.
In 2016, Joe travelled to Nepal with Impact Marathon to run in the Himalayas and build a 5K water pipeline in line with the UN Sustainable Development (SD) Goals. In March 2018, he led a team of 13 Canadians in Guatemala to run a race up a volcano and participate in a project to help build a youth leadership centre. Find out more here on Run Ottawa.
Joe is currently assembling a team of 30 Canadians to join him in his next adventure in Malawi in May 2019. There he will be supporting three of the UN SD Goals: No Poverty, Zero Hunger, Good Health & Well Being.


text:
EFF's Privacy Badger tells you when websites ignore 'Do Not Track' settings
Tom Cheredar	 May 2, 2014 10:20 AM
Image Credit: EFF
A badger will now tattle on websites that ignore the "Do Not Track" feature built into web browsers.
OK, so this badger isn't actually a real animal, but rather the namesake behind the Electronic Frontier Foundation's new Privacy Badger browser plug-in, which launched last night.
The background: Major web browser makers have been working with advertisers on a feature that gives people the option to tell the sites they visit not to track their activity. This option, called Do Not Track, has been in development for several years, but is not yet supported by every website.
Part of the problem is that it relies on the honor system: With no legislative force behind it, websites can ignore the Do Not Track setting and grab your data regardless, without you even knowing. For example, Yahoo agreed to abide by the Do Not Track feature but recently decided to start tracking everyone again.
That's what Privacy Badger is for: to make a big deal when a website collects your data even though you have the "Do Not Track" setting turned on. Privacy Badger will block content (mostly advertising) from any site that ignores these settings, but won't disable all advertising from websites.
Here's the official explanation from the EFF:
When you visit websites, your copy of Privacy Badger keeps note of the "third-party" domains that embed images, scripts and advertising in the pages you visit.
If a third-party server appears to be tracking you without permission, by using uniquely identifying cookies to collect a record of the pages you visit across multiple sites, Privacy Badger will automatically disallow content from that third-party tracker. In some cases a third-party domain provides some important aspect of a page's functionality, such as embedded maps, images, or fonts. In those cases, Privacy Badger will allow connections to the third party but will screen out its tracking cookies.
Identifying how a website tracks and collects your data isn't something new. The browser plugins NoScript and Ghostery can identify what's running in the background when you visit a site, and even give you some degree of security by blocking those sites from doing it.
Yet EFF's Privacy Badger might have the right idea by focusing on transparency more than action. Because if you know a website is ignoring your Do Not Track setting, it might influence how you use the web in the future.
The Privacy Badger plug-in is free and available now on both Google's Chrome browser and Firefox.


text:
Why Are Giant Letters Appearing All Around Dubai
Have you driven around Sheikh Zayed or Kite Beach area lately? Did you notice one of those giant letters that have been installed on the sides of the road? What do you think it has to do with? Traffic laws? Tourism? Neither actually.
Sheikh Hamdan's reveal
Last month, the Crown Prince of Dubai, HH Sheikh Hamdan bin Mohammed Al Maktoum, disclosed that the city of Dubai was getting its own typeface called the "Dubai Font". The Crown Prince and Chairman of the Executive Council has declared that all governing authorities must employ the use of the brand new font for all future communications.
The Royal who played a crucial role in the development of the font has stressed upon the importance of the font's launch as it's a part of the persistent measures to excel in the digital universe.
Significance of the initiative
General Secretariat Affairs Sector of Dubai and Assistant Secretary-General for the Executive Council, Ahmad Al Mahdi, is the Project Director of Dubai Font has said that the Dubai Font is more than just a mode of expressing and reading on a digital medium, it will encourage communication. After all, it combines the ancient and much-respected history of the emirate city to its contemporary glory and the vision of a spectacular tomorrow.
He also noted that the aim of the initiative was to empower the residents of the city to contribute to a digital footprint in numerous fields. He assured that the font was necessary to provide new and clever ways to incorporate technology and introduce it to the citizens in a manner which will make them proud and happy, thus encouraging them to self-expression.
Dubai Font
"Dubai Font" which was created in collaboration with Microsoft is being launched as an initiative, aiming to encourage citizens to read, write, and express, with the slogan and hashtag "#ExpressYou". This is the first time ever that the digital mogul has conceived a typeface for and with a city.
The exceptional initiative is supposed to reflect the fundamental values of the emirate: happiness, generosity, respect, tolerance, modernity, brightness and harmonized living. The new font is available in 23 different languages including Arabic, Latin and more, to emphasize on living in harmony.
You can download the font online from the website. You can choose between regular, light, medium, and bold. About 100 million MS Office 360 users can avail the font.
Instagram Opportunity
However, if you want to view the giant, photogenic letter apart from your device screens you can head to some of the roads all across the city. So far the letters measuring several meters in height can be found at Sheikh Zayed Road, Sheikh Mohammed Bin Rashid Boulevard, Dubai Mall and Kite Beach. You should be able to find some more on other major roads.
Because so many letters in Arabic, as well as Latin characters, have started appearing around the emirate, people are clicking selfies and portraits to upload and share on their social media handles. As a matter of fact, initially when the giant letters started to spring up a whole lot of residents took to social media out of curiosity and to figure out what was up.
So, here's to more landmarks and photo ops for tourists visiting Dubai this summer.
5 Refreshing Ideas to Help you Cool Down this Summer in Dubai
Fun Activities You Can Now Enjoy Again in Dubai
Top 6 Podcast Platform
Top Suggested Podcast You Should Listen To


Ganergy Heavy Industry Group (GNG) was established in 1956, which is the leading enterprise in the field of large-scale oil drilling-production equipment manufacture. Our group is also the long-term strategic partner of CNPC, SINOPEC, CNOOC and Yanchang Petroleum, the National Torch Base of Oil Drilling Equipment. It integrates oil and gas equipment manufacturing, energy development, oil field operations and financial services. Our group consists of a large number of subsidiaries which can be classified into equipment manufacture sector, engineering service sector, financing service sector and international business sector, and owns storage yard and special railway lines, possesses a registered capital of RMB 3.8 billion, and covers a total area of million m2 with a building area of 4.8 million m2, and there are 18,000 employees.
GNG has an experienced technical team consisting of 50 senior experts, 65 doctor degree talents, 150 senior engineers, 850 engineers and 36 high-level superintendents. It possesses a national-level Technology R&D Center, a Machining Center, a Hydraulic Pressure Test Center, a Physicochemical Experiment Center and a Nondestructive Examination Center with the advanced manufacture equipment and complete detection means. The group is the postgraduate training base of Northeast Petroleum University, Liaoning Technical University, Dalian University of Technology. GNG has established a long-term strategic cooperation relationship with UPSE state university of Ecuador and a number of domestic and abroad scientific research institutions. The group has been awarded more than 1500 items of national patents, and awarded as the only "National Torch Base of Oil Drilling Equipment" in China.
GNG has passed ISO9001:2000 Quality System Certification and has gotten the right to use the official API 7K, 8C, 4F, Q1 Monograms. Based on the principle of "Quality First and Customers First", the group continuously researches and develops new marketable products, ensures product quality with advanced quality management and the satisfaction of customers with sincere services. To meet the high quality requirements of the customer is the pursuit of the group, which is also the need to the competitiveness of the products and exuberant vitality of the group. Following the development trend of oil drilling equipment domestic and overseas, the group continuously increases technology investment, which makes it the first place of the industry in the research and development of new products.
GNG supplies a complete set of oil drilling equipment and related accessories for customers domestic and overseas, the main products consist of offshore drilling platforms and various marine engineering modules, digital skid-mounted drilling rig series, truck-mounted drilling rig series, trailer-mounted drilling rig series, self-propelled workover rig series, complete set of fracturing units, truck crane series, LNG transport vehicle, operation devices with pressure, top drives, mud pumps, complete sets of drilling tools, hydraulic power tong series, wellhead tool series and so on.
GNG has its own sales offices in all the major oilfield in China and a few branches abroad as well with technical serviceman, offering best pre-sale, in-sale and after-sale services.
GNG always sticks to the management philosophy of "Science and Technology as Guide, Quality as Core", and commits ourselves to "Always surprise the customers with the service beyond the requirements of customers".


text:
Home / Health News / World Hepatitis Day: Do you know? Regular screening of liver a must
World Hepatitis Day: Do you know? Regular screening of liver a must
Hepatitis is widespread in India, standing fourth among 11 countries which carry almost 50 per cent of the global burden of chronic hepatitis.
By: ANI | | Published: July 28, 2018 11:17 am
Tags: Fatty liver hepatitis cure liver cell Liver cells Liver health
Tips to tackle cirrhosis of liver. © Shutterstock
Globally every year 1.4 million people die from hepatitis, which can be transmitted from the mother to baby, via sexual contact or upon contact with infected blood. Also Read - Sensor to detect fatty liver disease even before they have obvious symptoms developed
Inflammation of the liver (commonly known as hepatitis) can result from viral infection and as all the symptoms are nearly close enough, without a diagnostic test, it is impossible to differentiate. Also Read - Meet the 3 scientists who jointly won Nobel Prize in medicine for Hepatitis C virus discovery
Lack of regular checkup and diagnosis is the prime reason for being undetected. Globally around 400 million people are infected with the hepatitis B virus in the world today and a prime reason for it is liver failure and cancer. Also Read - Detoxify your liver with avocado, carrots and more
As the function of the liver is to help in digestion by producing proteins, enzymes, and other substances, clear toxins from the body, any abnormality in the production of the components is a serious indication of an ailment that the liver is not functioning well.
"In case suspecting an improper functioning of the liver, liver function test (LFT) may be done wherein a sample of blood is taken for analysis. The following substances if found abnormally, is an indication of hepatitis," Dr. Vinay Aggarwal, Past National President, Indian Medical Association.
Albumin is a protein synthesized by the liver to help move the minerals and required nutrients into the blood. Low levels of this protein are a serious sign of liver disease. Enzymes are synthesized by the liver of which ALP is necessary for bone growth, ALT assists in processing protein and AST help in converting food to energy.
A person suffering from hepatitis will have high levels of these enzymes in the blood Bilirubin- the patient will have high levels of this pigment which is also responsible for causing jaundice, which is produced when the RBC breaks down.
According to Dr. Ruchi Gupta Founder of 3h care.in, "To obtain the severity, type and which strain of hepatitis a person is suffering from, Viral serology is a series of blood tests conducted for screening complete details of the liver."
"The sample is checked for specific markers of the invading virus and its antibodies that fight them off. Such tests are useful in the long-term management of patients with hepatitis, to keep a track on the treatment progression. The disappearance of antigens from the blood is an indication that the infection is clearing," she added.
The blood is tested for the following antigens and antibodies-
-Antigens – Hepatitis A, Hepatitis B (surface and core), Hepatitis C
-Antibodies against – Hepatitis A, Hepatitis B (surface and e-antigens) and Hepatitis C
– IgM antibody – the presence of which indicates a recent infection
– IgG antibody – whose presence indicates ongoing exposure to the virus
To determine the type and severity of hepatitis, a combination of tests need to be conducted for identifying the progression, in order to decide the best course of action.
Published : July 28, 2018 11:17 am
Did you know? Portfolio diet can lowers heart disease risk
Beware: Your tattoo can give you Hepatitis B
Ayurvedic tips to keep your liver healthy in 2021
Sensor to detect fatty liver disease even before they have obvious symptoms developed
Meet the 3 scientists who jointly won Nobel Prize in medicine for Hepatitis C virus discovery
Cabbage can help you fight non-alcoholic fatty liver disease: Other natural solutions to try
Detoxify your liver with avocado, carrots and more


More images of the folding board itself - and visual guide to assembling a folded board!
"sales at pacru.com" . Delivery should be within two weeks currently for the UK, mainland Europe and Ireland.
Depending on where you purchase, the Series 302 board is around 35 pounds sterling, or 52 euros (these figures include European Community Tax VAT). If buying mail-order there will be post and packing in addition.


text:
faqs.org > Rulings and Tariffs Home > Rulings By Number > 2002 NY Rulings > NY H89648 - NY H89699 > NY H89686
NY H89686
CLA-2-64:RR:NC:TA:347 H89686
TARIFF NO.: 6406.10.6500 ; 6406.10.9040 ; 6307.90.9889
Mr. Rajko Sajovec
Romika USA, Inc.
RE: The tariff classification of footwear uppers from China and India.
Dear Mr. Sajovec:
In your letter dated March 21, 2002 you requested a tariff classification ruling.
You have submitted two styles of footwear uppers without outer soles, identified as style Memphis 14, which has an external surface of leather, from India, and style W/9048, from China, which has a man-made textile material external surface. Both samples have a sock bottom or underfoot sewn onto their respective uppers and there is an approximately 7/8-inch diameter hole that has been cut out of each sock bottom in the heel area of an otherwise closed underfoot. In addition, we find that a heel stiffener has been assembled into the leather shoe upper sample and the insertion of the stiffener does provide for some significant shaping of this upper, even if no other molding or heat shaping has yet occurred. We presume that it is after importation into the United States that these uppers will be lasted to their final shape by undergoing some heat treatment forming and by having their respective outer soles applied by some sort of injection molding or cementing process to become finished shoes.
In determining whether or not to classify uppers as "formed", one of the factors we look to is whether the bottom of the upper is closed. Since both these sample uppers have completely sewn on sock bottoms, we could say that these uppers have closed bottoms. However, each upper does also have an approximately 7/8-inch wide hole cut out of its bottom. Headquarters Ruling Letter (HRL) 082573, dated December 28, 1989, stated that "uppers which have substantial openings cut out of the bottoms are not closed within the meaning of Additional U.S. Note 4 to chapter 64, Supra." Additionally, HRL 954790, dated September 28, 1993, ruled that the term "formed uppers" did not include moccasin uppers with a significant sized hole (the size of a nickel or larger) in their bottom layer, whether or not the upper is fully formed (lasted), unless the piece which will cover that opening was in the same shipment. Since both the sample uppers have openings of as much as 7/8-inch in diameter (nickel size or larger) cut out of their bottoms and provided that the pieces which will cover those openings are not in the same shipment at importation, they will not be considered "formed uppers" for tariff purposes.
Therefore, the applicable subheading for the shoe upper, identified as style Memphis 14 from India, will be 6406.10.6500, Harmonized Tariff Schedule of the United States (HTS), which provides for footwear uppers and parts thereof, which are not "formed uppers" and in which the upper's external surface is predominately leather. The rate of duty will be Free.
The applicable subheading for the shoe upper identified as style W/9048 from China, will be 6406.10.9040, HTS, which provides for footwear uppers and parts thereof, which are not "formed uppers", and in which the upper's external surface is predominately of textile material of man-made fibers. The rate of duty will be 5.4% ad valorem.
We note that this textile shoe upper also has a flat braided textile shoelace, we presume of man-made textile fiber, laced into its eyelets. Previous Customs rulings have determined that a readily removable shoelace, laced into the eyelets of a footwear upper that is not a "formed upper" does not constitute a composite good nor a set and so the laces will be separately classified. Therefore, the applicable subheading for this flat textile shoelace will be 6307.90.9889, HTS, which provides for "other made up textile articles." The rate of duty will be 7% ad valorem.
A copy of the ruling or the control number indicated above should be provided with the entry documents filed at the time this merchandise is imported. If you have any questions regarding the ruling, contact National Import Specialist Richard Foley at 646-733-3042.
Robert B. Swierupski
Tariff No.: 6307.90.98 - National flags and other made-up articles of textile materials, nesoi
Tariff No.: 6406.10.65 - Uppers & pts. thereof for footwear, nesoi, of leather
Tariff No.: 6406.10.90 - Uppers & pts. thereof for footwear, nesoi


On 27 April 2018 the EU-Australia Leadership Forum held a very successful Sectoral Policy Workshop on the topic of the rules-based international order.
The event, based in Brussels, brought together a total of 28 European and Australian participants, including high-level experts, to discuss perspectives on, and threats to, the rules-based international order.
The Sectoral Policy Workshop was chaired by Quentin Peel (Associate Fellow, Chatham House and former international affairs editor, Financial Times) and Dr Carl Ungerer (Former adviser to Minister for Foreign Affairs Senator the Hon Bob Carr and former head of the Leadership, Crisis and Conflict Management Program at the Geneva Centre for Security Policy).
Key recommendations from the workshop will be presented to the official EU-Australia Strategic/Security Dialogue in May 2018.
For further information, download the Co-Chair's Background Papers and Event Programme.


So…up until now I have never been to a blow dry bar. The idea has always sounded so fun, but last the same time I figured, 'Hey, I can blow dry my own hair right?!' But that perspective of mine has now been completely changed.
We worked with one of our favorite bloggers, Jacqui Kruger, to capture photos of her experience at the Dry Bar and I learned a whole lot more about what a dry bar really does! We had so much fun shooting details around the salon and photographing the entire process from a wash out to blow out to styling! Jacqui left with her hair game on point and ready to take on the rest of our time together!
Jacqui's hair is naturally just gorgeous, and we loved it when she switched things up and put it in a quick up-do for fall fashion photos on rooftop deck at Mountain Shadows Resort in Scottsdale, AZ. Even though our temperatures here in AZ are still unsure if it's summer or fall, her high fashion leather jacket and leopard print scarf had us feeling all of the fall and winter weather vibes!
Take a scroll through the photos below for some fun fall fashion inspiration from the always amazing Jacqui Kruger! And if you're like me and you've never been to the Dry Bar, see more about what an experience there looks like!


What are MACROS and should you count them?
Macronutrients, or MACROS, are broken down into Protein, Carbohydrates, and Fats. These are the building blocks of the foods that we eat and the energy we can expend.
Each macronutrient is calculated differently when it comes to contributing to your overall calorie and nutritional intake. Proteins and Carbohydrates are calculated at 4 calories per gram, while Fat is calculated at 9 calories per gram. Though Sugar is not considered in a macronutrient count, it is important to note that they calculate in at 7 calories per gram and act like a carbohydrate when calculating your overall intake for a day.
When you follow a macro diet, you go beyond counting calories and focus on tracking macros. Depending on your health goals, you can adjust the ratios of macronutrients you consume to lose weight, build muscle, or enter maintenance mode.
How many macros should you be eating per day or per meal? The way your body utilizes each macronutrient will be a determining factor. It also depends on your goals. Are you trying to lean out? Are you trying to add muscle tissue? What if you want to do both?!
Depending on your DNA, your goals, and your starting point, the amount of each macronutrient will vary. Do you need more protein and less fat? What if you have an enhanced ability to utilize carbohydrates (sorry that doesn't mean you get to eat all the cookies and all the bread!)? What is ideal to eat and how much?
So do you want to count them? If so, what does that look like?
Let us know if you have any questions or want to know what your ideal macro breakdown looks like. We are here to serve you and help you reach your goals!