Changed values passed to SetClientSize() in CreateWidgets() so that buttons are not...

[wxWidgets.git] / src / common / socket.cpp

diff --git a/src/common/socket.cpp b/src/common/socket.cpp
index 08af3c1959c0d90551436127abe170313055eccd..ecb0781c7c4866fbb8a28a650aaa110159581be5 100644 (file)
--- a/src/common/socket.cpp
+++ b/src/common/socket.cpp
@@ -54,7 +54,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
 
 class wxSocketState : public wxObject {
 public:
 
 class wxSocketState : public wxObject {
 public:

-  bool notify_state; 
+  bool notify_state;

   GSocketEventFlags evt_notify_state;
   wxSocketBase::wxSockFlags socket_flags;
   wxSocketBase::wxSockCbk c_callback;
   GSocketEventFlags evt_notify_state;
   wxSocketBase::wxSockFlags socket_flags;
   wxSocketBase::wxSockCbk c_callback;


@@ -72,7 +72,7 @@ wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags,
   wxEvtHandler(),
   m_socket(NULL), m_flags(_flags), m_type(_type),
   m_neededreq(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG),
   wxEvtHandler(),
   m_socket(NULL), m_flags(_flags), m_type(_type),
   m_neededreq(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG),

-  m_lcount(0), m_timeout(3600),
+  m_lcount(0), m_timeout(600),

   m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
   m_cbk(NULL), m_cdata(NULL),
   m_connected(FALSE), m_notify_state(FALSE), m_id(-1),
   m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
   m_cbk(NULL), m_cdata(NULL),
   m_connected(FALSE), m_notify_state(FALSE), m_id(-1),


@@ -85,7 +85,7 @@ wxSocketBase::wxSocketBase() :
   wxEvtHandler(),
   m_socket(NULL), m_flags(SPEED | WAITALL), m_type(SOCK_UNINIT),
   m_neededreq(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG),
   wxEvtHandler(),
   m_socket(NULL), m_flags(SPEED | WAITALL), m_type(SOCK_UNINIT),
   m_neededreq(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG),

-  m_lcount(0), m_timeout(3600),
+  m_lcount(0), m_timeout(600),

   m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
   m_cbk(NULL), m_cdata(NULL),
   m_connected(FALSE), m_notify_state(FALSE), m_id(-1),
   m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
   m_cbk(NULL), m_cdata(NULL),
   m_connected(FALSE), m_notify_state(FALSE), m_id(-1),


@@ -112,7 +112,7 @@ wxSocketBase::~wxSocketBase()
 
 bool wxSocketBase::Close()
 {
 
 bool wxSocketBase::Close()
 {

-  if (m_socket) 
+  if (m_socket)

   {
     if (m_notify_state == TRUE)
       Notify(FALSE);
   {
     if (m_notify_state == TRUE)
       Notify(FALSE);


@@ -128,32 +128,62 @@ bool wxSocketBase::Close()
 // --------------------------------------------------------------
 // wxSocketBase base IO function
 // --------------------------------------------------------------
 // --------------------------------------------------------------
 // wxSocketBase base IO function
 // --------------------------------------------------------------

+class _wxSocketInternalTimer: public wxTimer {
+ public:
+  int *m_state;
+  unsigned long m_new_val;
+
+  void Notify()
+     {
+        *m_state = m_new_val;  // Change the value
+     }
+};

 
 int wxSocketBase::DeferRead(char *buffer, size_t nbytes)
 {
   GSocketEventFlags old_event_flags;
   bool old_notify_state;
 
 int wxSocketBase::DeferRead(char *buffer, size_t nbytes)
 {
   GSocketEventFlags old_event_flags;
   bool old_notify_state;

+  // Timer for timeout
+  _wxSocketInternalTimer timer;

 
   wxASSERT(m_defering == NO_DEFER);
 
 
   wxASSERT(m_defering == NO_DEFER);
 

+  // Set the defering mode to READ.

   m_defering = DEFER_READ;
 
   m_defering = DEFER_READ;
 

+  // Save the old state.

   old_event_flags = NeededReq();
   old_notify_state = m_notify_state;
   old_event_flags = NeededReq();
   old_notify_state = m_notify_state;

-  
+
+  // Set the new async flag.

   SetNotify(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG);
   Notify(TRUE);
 
   SetNotify(GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG);
   Notify(TRUE);
 

+  // Set the current buffer.

   m_defer_buffer = buffer;
   m_defer_nbytes = nbytes;
   m_defer_buffer = buffer;
   m_defer_nbytes = nbytes;

+  m_defer_timer  = &timer;
+
+  timer.m_state = (int *)&m_defer_buffer;
+  timer.m_new_val = 0;
+
+  timer.Start(m_timeout * 1000, FALSE);
+
+  // Wait for buffer completion. 

   while (m_defer_buffer != NULL)
     wxYield();
 
   while (m_defer_buffer != NULL)
     wxYield();
 

+  timer.Stop();
+
+  // Restore the old state.

   Notify(old_notify_state);
   SetNotify(old_event_flags);
 
   Notify(old_notify_state);
   SetNotify(old_event_flags);
 

+  // Disable defering mode.

   m_defering = NO_DEFER;
   m_defering = NO_DEFER;

+  m_defer_timer = NULL;

 
 

+  // Return the number of bytes read from the socket.

   return nbytes-m_defer_nbytes;
 }
 
   return nbytes-m_defer_nbytes;
 }
 


@@ -272,22 +302,39 @@ int wxSocketBase::DeferWrite(const char *buffer, size_t nbytes)
 {
   GSocketEventFlags old_event_flags;
   bool old_notify_state;
 {
   GSocketEventFlags old_event_flags;
   bool old_notify_state;

+  // Timer for timeout
+  _wxSocketInternalTimer timer;

 
   wxASSERT(m_defering == NO_DEFER);
 
   m_defering = DEFER_WRITE;
 
 
   wxASSERT(m_defering == NO_DEFER);
 
   m_defering = DEFER_WRITE;
 

+  // Save the old state

   old_event_flags = NeededReq();
   old_notify_state = m_notify_state;
 
   SetNotify(GSOCK_OUTPUT_FLAG | GSOCK_LOST_FLAG);
   Notify(TRUE);
 
   old_event_flags = NeededReq();
   old_notify_state = m_notify_state;
 
   SetNotify(GSOCK_OUTPUT_FLAG | GSOCK_LOST_FLAG);
   Notify(TRUE);
 

+  // Set the current buffer

   m_defer_buffer = (char *)buffer;
   m_defer_nbytes = nbytes;
   m_defer_buffer = (char *)buffer;
   m_defer_nbytes = nbytes;

+
+  // Start timer
+  timer.m_state   = (int *)&m_defer_buffer;
+  timer.m_new_val = 0;
+
+  m_defer_timer   = &timer;
+  timer.Start(m_timeout * 1000, FALSE);
+

   while (m_defer_buffer != NULL)
     wxYield();
 
   while (m_defer_buffer != NULL)
     wxYield();
 

+  // Stop timer
+  m_defer_timer = NULL;
+  timer.Stop();
+
+  // Restore the old state

   Notify(old_notify_state);
   SetNotify(old_event_flags);
 
   Notify(old_notify_state);
   SetNotify(old_event_flags);
 


@@ -396,11 +443,15 @@ void wxSocketBase::DoDefer(GSocketEvent req_evt)
   if (ret < 0)
     m_defer_nbytes++;
 
   if (ret < 0)
     m_defer_nbytes++;
 

+  // If we are waiting for all bytes to be acquired, keep the defering modei
+  // enabled.

   if ((m_flags & WAITALL) == 0 || m_defer_nbytes == 0 || ret < 0) {
     m_defer_buffer = NULL;
     Notify(FALSE);
   if ((m_flags & WAITALL) == 0 || m_defer_nbytes == 0 || ret < 0) {
     m_defer_buffer = NULL;
     Notify(FALSE);

-  } else
+  } else {

     m_defer_buffer += ret;
     m_defer_buffer += ret;

+    m_defer_timer->Start(m_timeout * 1000, FALSE);
+  }

 }
 
 // ---------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------


@@ -415,7 +466,7 @@ void wxSocketBase::Discard()
   SaveState();
   SetFlags(NOWAIT | SPEED);
 
   SaveState();
   SetFlags(NOWAIT | SPEED);
 

-  while (recv_size == MAX_BUFSIZE) 
+  while (recv_size == MAX_BUFSIZE)

   {
     recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
   }
   {
     recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
   }


@@ -522,16 +573,6 @@ char *wxSocketBase::CallbackData(char *data)
 // --------- wxSocketBase wait functions ------------------------
 // --------------------------------------------------------------
 
 // --------- wxSocketBase wait functions ------------------------
 // --------------------------------------------------------------
 

-class _wxSocketInternalTimer: public wxTimer {
- public:
-  int *m_state;
-
-  void Notify()
-     {
-        *m_state = GSOCK_MAX_EVENT;  // Just to say it's a timeout.
-     }
-};
-

 static void wx_socket_wait(GSocket *socket, GSocketEvent event, char *cdata)
 {
   int *state = (int *)cdata;
 static void wx_socket_wait(GSocket *socket, GSocketEvent event, char *cdata)
 {
   int *state = (int *)cdata;


@@ -542,25 +583,30 @@ static void wx_socket_wait(GSocket *socket, GSocketEvent event, char *cdata)
 bool wxSocketBase::_Wait(long seconds, long milliseconds, int type)
 {
   bool old_notify_state = m_notify_state;
 bool wxSocketBase::_Wait(long seconds, long milliseconds, int type)
 {
   bool old_notify_state = m_notify_state;

-  int state = 0;
+  int state = -1;

   _wxSocketInternalTimer timer;
 
   if (!m_connected || !m_socket)
     return FALSE;
 
   _wxSocketInternalTimer timer;
 
   if (!m_connected || !m_socket)
     return FALSE;
 

+  // Set the variable to change

   timer.m_state = &state;
   timer.m_state = &state;

+  timer.m_new_val = GSOCK_MAX_EVENT;

 
 

+  // Disable the previous handler

   Notify(FALSE);
 
   Notify(FALSE);
 

+  // Set the timeout

   timer.Start(seconds * 1000 + milliseconds, TRUE);
   timer.Start(seconds * 1000 + milliseconds, TRUE);

-  GSocket_SetFallback(m_socket, type, wx_socket_wait, (char *)&state);
+  GSocket_SetCallback(m_socket, type, wx_socket_wait, (char *)&state);

 
 

-  while (state == 0)
+  while (state == -1)

     wxYield();
 
     wxYield();
 

-  GSocket_UnsetFallback(m_socket, type);
+  GSocket_UnsetCallback(m_socket, type);

   timer.Stop();
 
   timer.Stop();
 

+  // Notify will restore automatically the old GSocket flags

   Notify(old_notify_state);
 
   return (state != GSOCK_MAX_EVENT);
   Notify(old_notify_state);
 
   return (state != GSOCK_MAX_EVENT);


@@ -593,7 +639,7 @@ bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 
 GSocketEventFlags wxSocketBase::EventToNotify(GSocketEvent evt)
 {
 
 GSocketEventFlags wxSocketBase::EventToNotify(GSocketEvent evt)
 {

-  switch (evt) 
+  switch (evt)

   {
   case GSOCK_INPUT:
     return GSOCK_INPUT_FLAG;
   {
   case GSOCK_INPUT:
     return GSOCK_INPUT_FLAG;


@@ -601,7 +647,7 @@ GSocketEventFlags wxSocketBase::EventToNotify(GSocketEvent evt)
     return GSOCK_OUTPUT_FLAG;
   case GSOCK_CONNECTION:
     return GSOCK_CONNECTION_FLAG;
     return GSOCK_OUTPUT_FLAG;
   case GSOCK_CONNECTION:
     return GSOCK_CONNECTION_FLAG;

-  case GSOCK_LOST_FLAG:
+  case GSOCK_LOST:

     return GSOCK_LOST_FLAG;
   default:
     return 0;
     return GSOCK_LOST_FLAG;
   default:
     return 0;


@@ -649,12 +695,12 @@ void wxSocketBase::Notify(bool notify)
   if (!m_socket)
     return;
 
   if (!m_socket)
     return;
 

-  GSocket_UnsetFallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+  GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |

                                   GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
   if (!notify)
     return;
 
                                   GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
   if (!notify)
     return;
 

-  GSocket_SetFallback(m_socket, m_neededreq, wx_socket_fallback, (char *)this);
+  GSocket_SetCallback(m_socket, m_neededreq, wx_socket_fallback, (char *)this);

 }
 
 void wxSocketBase::OnRequest(GSocketEvent req_evt)
 }
 
 void wxSocketBase::OnRequest(GSocketEvent req_evt)


@@ -724,7 +770,7 @@ void wxSocketBase::CreatePushbackBefore(const char *buffer, size_t size)
 
     m_unread = tmp;
   }
 
     m_unread = tmp;
   }

-  
+

   m_unrd_size += size;
 
   memcpy(m_unread, buffer, size);
   m_unrd_size += size;
 
   memcpy(m_unread, buffer, size);


@@ -846,9 +892,8 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) )
   // Update the flags of m_socket.
   SetFlags(m_flags);
   GSocket_SetPeer(m_socket, addr_man.GetAddress());
   // Update the flags of m_socket.
   SetFlags(m_flags);
   GSocket_SetPeer(m_socket, addr_man.GetAddress());

-  if (GSocket_Connect(m_socket, GSOCK_STREAMED) != GSOCK_NOERROR) {
+  if (GSocket_Connect(m_socket, GSOCK_STREAMED) != GSOCK_NOERROR)

     return FALSE;
     return FALSE;

-  }

 
   // Enables bg events.
   // ------------------
 
   // Enables bg events.
   // ------------------


@@ -870,9 +915,9 @@ bool wxSocketClient::WaitOnConnect(long seconds, long microseconds)
 
 void wxSocketClient::OnRequest(GSocketEvent evt)
 {
 
 void wxSocketClient::OnRequest(GSocketEvent evt)
 {

-  if (evt == GSOCK_CONNECTION) 
+  if (evt == GSOCK_CONNECTION)

   {
   {

-    if (m_connected) 
+    if (m_connected)

     {
       m_neededreq &= ~GSOCK_CONNECTION_FLAG;
       return;
     {
       m_neededreq &= ~GSOCK_CONNECTION_FLAG;
       return;


@@ -905,5 +950,21 @@ void wxSocketEvent::CopyObject(wxObject& obj_d) const
   event->m_socket = m_socket;
 }
 
   event->m_socket = m_socket;
 }
 

+// --------------------------------------------------------------------------
+// wxSocketModule
+// --------------------------------------------------------------------------
+class WXDLLEXPORT wxSocketModule: public wxModule {
+  DECLARE_DYNAMIC_CLASS(wxSocketModule)
+ public:
+  bool OnInit() {
+    return GSocket_Init();
+  }
+  void OnExit() {
+    GSocket_Cleanup();
+  }
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
+

 #endif
   // wxUSE_SOCKETS
 #endif
   // wxUSE_SOCKETS