Blinker

@@ -27,17 +27,18 @@ namespace Blinker {

 Canvas::Input::Input(Canvas &canvas, const Directory &dirBase):

   m_canvas(canvas),

   m_fileInStream(dirBase.getFile("instream")),

-  m_filePosition(dirBase.getFile("position")),

+  m_fileSrcPos(dirBase.getFile("srcpos")),

   m_fileSize(dirBase.getFile("size")),

-  m_havePosition(false),

-  m_haveSize(false),

+  m_fileDestPos(dirBase.getFile("destpos")),

   m_pInStream(NULL),

-  m_ownFrame(false),

-  m_pFrame(NULL)

+  m_haveSrcPos(false),

+  m_haveSize(false),

+  m_haveDestPos(false)

 {

   // get setting and attach to input stream

-  getPosition();

+  getSrcPos();

   getSize();

+  getDestPos();

   getInStream();

 }

@@ -57,15 +58,13 @@ void Canvas::Input::updateConfig()

     getInStream();

   }

-  // position file was modified -> re-get position

-  if (m_filePosition.checkModified()) {

-    getPosition();

-  }

-

-  // size file was modified -> re-get size

-  if (m_fileSize.checkModified()) {

+  // position/size files were modified -> re-get position/size

+  if (m_fileSrcPos.checkModified())

+    getSrcPos();

+  if (m_fileSize.checkModified())

     getSize();

-  }

+  if (m_fileDestPos.checkModified())

+    getDestPos();

 }

 /**

@@ -75,12 +74,10 @@ void Canvas::Input::updateConfig()

  */

 void Canvas::Input::setFrame(const std::string &stream, stBlinkenFrame *pFrame)

 {

-  // prepare frame

-  prepareFrame(pFrame);

-

   // notify canvas to redraw

   m_canvas.redraw();

+  (void)pFrame; // unused (frame fetched from stream when requested to draw)

   (void)stream; // unused

 }

@@ -90,9 +87,6 @@ void Canvas::Input::setFrame(const std::string &stream, stBlinkenFrame *pFrame)

  */

 void Canvas::Input::setNoFrame(const std::string &stream)

 {

-  // throw away prepared frame

-  unprepareFrame();

-

   // notify canvas to redraw

   m_canvas.redraw();

@@ -105,15 +99,33 @@ void Canvas::Input::setNoFrame(const std::string &stream)

  */

 bool Canvas::Input::draw()

 {

-  // no position, no frame or no canvas -> leave

-  if (!m_havePosition || !m_pFrame || !m_canvas.m_pCanvas)

+  stBlinkenFrame *pFrame;

+

+  // no destination position or no canvas -> leave

+  if (!m_haveDestPos || !m_canvas.m_pCanvas)

     return false;

-  // draw frame to canvas

-  BlinkenFrameCopyRect(m_canvas.m_pCanvas, m_position.m_y, m_position.m_x,

-                       m_pFrame, 0, 0,

-                       BlinkenFrameGetHeight(m_pFrame),

-                       BlinkenFrameGetWidth(m_pFrame));

+  // get current frame from stream (levae if no stream or no frame)

+  if (!m_pInStream || !m_pInStream->getCurFrame(pFrame))

+    return false;

+

+  // no source position -> use top left

+  if (!m_haveSrcPos) {

+    m_srcPos.m_x = 0;

+    m_srcPos.m_y = 0;

+  }

+

+  // no size -> use entire source frame

+  //            (BlinkenLib will clip this if too large)

+  if (!m_haveSize) {

+    m_size.m_width = BlinkenFrameGetWidth(pFrame);

+    m_size.m_height = BlinkenFrameGetHeight(pFrame);

+  }

+

+  // draw rectangular area to canvas

+  BlinkenFrameCopyRect(m_canvas.m_pCanvas, m_destPos.m_y, m_destPos.m_x,

+                       pFrame, m_srcPos.m_y, m_srcPos.m_x,

+                       m_size.m_height, m_size.m_width);

   return true;

 }

@@ -135,9 +147,6 @@ void Canvas::Input::getInStream()

 /// detach from input stream and release it

 void Canvas::Input::releaseInStream()

 {

-  // get rid of prepared frame

-  unprepareFrame();

-

   // detach from input stream

   if (m_pInStream)

     m_pInStream->detach(this);

@@ -150,86 +159,40 @@ void Canvas::Input::releaseInStream()

   m_canvas.redraw();

 }

-/// (re-)get position of stream on canvas

-void Canvas::Input::getPosition()

+/// (re-)get position of area to copy from stream

+void Canvas::Input::getSrcPos()

 {

   std::string strPos;

-  // read position from position file

-  m_havePosition = m_filePosition.getStr(strPos) && m_position.fromStr(strPos);

+  // read source position from file and parse it

+  m_haveSrcPos = m_fileSrcPos.getStr(strPos) && m_srcPos.fromStr(strPos);

   // notify canvas to redraw

   m_canvas.redraw();

 }

-/// (re-)get size of stream on canvas

+/// (re-)get size of area to copy from stream

 void Canvas::Input::getSize()

 {

   std::string strSize;

-  // read size from size file

+  // read size from file and parse it

   m_haveSize = m_fileSize.getStr(strSize) && m_size.fromStr(strSize);

-  // update prepared frame

-  updateFrame();

-

   // notify canvas to redraw

   m_canvas.redraw();

 }

-/// (un-)prepare frame based on current frame of stream

-void Canvas::Input::updateFrame()

+/// (re-)get destination position on canvas

+void Canvas::Input::getDestPos()

 {

-  stBlinkenFrame *pFrame;

-

-  // get current frame from stream

-  if (m_pInStream && m_pInStream->getCurFrame(pFrame)) {

-    // got a frame -> prepare it

-    prepareFrame(pFrame);

-  } else {

-    // no frame -> throw away prepared frame

-    unprepareFrame();

-  }

-}

-

-/**

- * @brief prepare frame (scale it if needed)

- * @param[in] pFrame frame to prepare

- */

-void Canvas::Input::prepareFrame(stBlinkenFrame *pFrame)

-{

-  // throw away old frame

-  unprepareFrame();

-

-  // no scaling needed

-  if (!m_haveSize ||

-      ((unsigned int)BlinkenFrameGetWidth(pFrame) == m_size.m_width &&

-       (unsigned int)BlinkenFrameGetHeight(pFrame) == m_size.m_height)) {

-    // just remember pointer

-    m_pFrame = pFrame;

-  }

-  // scaling needed

-  else {

-    // clone frame and scale it

-    m_pFrame = BlinkenFrameClone(pFrame);

-    if (m_pFrame) {

-      BlinkenFrameScale(m_pFrame, m_size.m_height, m_size.m_width);

-      m_ownFrame = true; // frame allocated ourself -> free it later

-    }

-  }

-}

+  std::string strPos;

-/// throw away prepared frame

-void Canvas::Input::unprepareFrame()

-{

-  // free frame if it was allocated ourself

-  if (m_ownFrame) {

-    BlinkenFrameFree(m_pFrame);

-    m_ownFrame = false;

-  }

+  // read destination position from file and parse it

+  m_haveDestPos = m_fileDestPos.getStr(strPos) && m_destPos.fromStr(strPos);

-  // no frame any more

-  m_pFrame = NULL;

+  // notify canvas to redraw

+  m_canvas.redraw();

 }

 } // namespace Blinker

@@ -72,37 +72,29 @@ protected:

   /// detach from input stream and release it

   void releaseInStream();

-  /// (re-)get position of stream on canvas

-  void getPosition();

+  /// (re-)get position of area to copy from stream

+  void getSrcPos();

-  /// (re-)get size of stream on canvas

+  /// (re-)get size of area to copy from stream

   void getSize();

-  /// (un-)prepare frame based on current frame of stream

-  void updateFrame();

-

-  /**

-   * @brief prepare frame (scale it if needed)

-   * @param[in] pFrame frame to prepare

-   */

-  void prepareFrame(stBlinkenFrame *pFrame);

-

-  /// throw away prepared frame

-  void unprepareFrame();

+  /// (re-)get destination position on canvas

+  void getDestPos();

 protected:

   Canvas         &m_canvas;      ///< owning canvas

   SettingFile    m_fileInStream; ///< input stream name file

-  SettingFile    m_filePosition; ///< position file

+  SettingFile    m_fileSrcPos;   ///< source position file

   SettingFile    m_fileSize;     ///< size file

+  SettingFile    m_fileDestPos;  ///< destination position file

   std::string    m_nameInStream; ///< name of input stream

-  bool           m_havePosition; ///< if position of stream on canvas is defined

-  Position       m_position;     ///< position of stream on canvas

-  bool           m_haveSize;     ///< if size of stream on canvas is defined

-  Size           m_size;         ///< size of stream on canvas

   Stream         *m_pInStream;   ///< input stream

-  bool           m_ownFrame;     ///< if the frame was allocated ourself

-  stBlinkenFrame *m_pFrame;      ///< frame to draw (already scaled to size)

+  bool           m_haveSrcPos;   ///< if copy-area src position is defined

+  Position       m_srcPos;       ///< copy-area position in source

+  bool           m_haveSize;     ///< if copy-area size is defined

+  Size           m_size;         ///< copy-area size

+  bool           m_haveDestPos;  ///< if copy-area dest position is defined

+  Position       m_destPos;      ///< copy-area position on canvas (i.e. dest)

 }; // class Canvas::Input

 } // namespace Blinker

@@ -26,11 +26,11 @@ Position::Position():

 bool Position::fromStr(const std::string &str)

 {

   StringParser parser(str);

-  int x, y;

+  unsigned int x, y;

-  if (!parser.sintNo(x) ||

+  if (!parser.uintNo(x) ||

       !parser.fixChr(',') ||

-      !parser.sintNo(y))

+      !parser.uintNo(y))

     return false;

   m_x = x;

   m_y = y;

@@ -32,8 +32,8 @@ public:

   std::string toStr() const;

 public:

-  int m_x; ///< X coordinate within a frame (in pixels)

-  int m_y; ///< Y ccordinate within a frame (in pixels)

+  unsigned int m_x; ///< X coordinate within a frame (in pixels)

+  unsigned int m_y; ///< Y ccordinate within a frame (in pixels)

 }; // class Position

 } // namespace Blinker