xemacs-beta: src/event-msw.c comparison

comparison src/event-msw.c @ 647:b39c14581166

[xemacs-hg @ 2001-08-13 04:45:47 by ben] removal of unsigned, size_t, etc.

author	ben
date	Mon, 13 Aug 2001 04:46:48 +0000
parents	38db05db9cb5
children	4035041996d8

comparison

equal deleted inserted replaced

-:00c54252fe4f
+:b39c14581166
 {
 struct ntpipe_slurp_stream* s = NTPIPE_SLURP_STREAM_DATA(stream);
 return s->thread_data->hev_caller;
 }
-static Lstream_data_count
+static Lstream_Data_Count
 ntpipe_slurp_reader (Lstream *stream, unsigned char *data,
-		     Lstream_data_count size)
+		     Lstream_Data_Count size)
 {
 /* This function must be called from the main thread only */
 struct ntpipe_slurp_stream_shared_data* s =
 NTPIPE_SLURP_STREAM_DATA(stream)->thread_data;
 	    /* Fetch available bytes. The same consideration applies,
 	       so do not check for errors. ReadFile in the thread will
 	       fail if the next call fails. */
 	    if (bytes_available)
-	      ReadFile (s->hpipe, data, min (bytes_available, size),
+	      ReadFile (s->hpipe, data, min (bytes_available, (DWORD) size),
 			&bytes_read, NULL);
 	  }
 	/* Now we can unblock thread, so it attempts to read more */
 	SetEvent (s->hev_thread);
 struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
 return s->user_data;
 }
 #endif
-static Lstream_data_count
+static Lstream_Data_Count
 ntpipe_shove_writer (Lstream *stream, const unsigned char *data,
-		     Lstream_data_count size)
+		     Lstream_Data_Count size)
 {
 struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
 if (s->error_p)
 return -1;
 struct winsock_stream
 {
 LPARAM user_data;		/* Any user data stored in the stream object */
 SOCKET s;			/* Socket handle (which is a Win32 handle)   */
 OVERLAPPED ov;		/* Overlapped I/O structure		     */
-void* buffer;			/* Buffer.                                   */
+void *buffer;			/* Buffer.                                   */
-unsigned long bufsize;	/* Number of bytes last read		     */
+DWORD bufsize;		/* Number of bytes last read		     */
-unsigned long bufpos;		/* Position in buffer for next fetch	     */
+DWORD bufpos;			/* Position in buffer for next fetch	     */
 unsigned int error_p :1;	/* I/O Error seen			     */
 unsigned int eof_p :1;	/* EOF Error seen			     */
 unsigned int pending_p :1;	/* There is a pending I/O operation	     */
 unsigned int blocking_p :1;	/* Last write attempt would block	     */
 };
 }
 else if (str->bufsize == 0)
 str->eof_p = 1;
 }
-static Lstream_data_count
+static Lstream_Data_Count
-winsock_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
+winsock_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size)
 {
 struct winsock_stream *str = WINSOCK_STREAM_DATA (stream);
 /* If the current operation is not yet complete, there's nothing to
 give back */
 return 0;
 if (str->error_p)
 return -1;
 /* Return as much of buffer as we have */
-size = min (size, (Lstream_data_count) (str->bufsize - str->bufpos));
+size = min (size, (Lstream_Data_Count) (str->bufsize - str->bufpos));
 memcpy (data, (void*)((BYTE*)str->buffer + str->bufpos), size);
 str->bufpos += size;
 /* Read more if buffer is exhausted */
 if (str->bufsize == str->bufpos)
 winsock_initiate_read (str);
 return size;
 }
-static Lstream_data_count
+static Lstream_Data_Count
 winsock_writer (Lstream *stream, const unsigned char *data,
-		Lstream_data_count size)
+		Lstream_Data_Count size)
 {
 struct winsock_stream *str = WINSOCK_STREAM_DATA (stream);
 if (str->pending_p)
 {
 * Used by emacs_mswindows_event_pending_p and emacs_mswindows_next_event
 */
 static void
 mswindows_need_event (int badly_p)
 {
-int active;
 while (NILP (mswindows_u_dispatch_event_queue)
 	 && NILP (mswindows_s_dispatch_event_queue))
 {
 #ifdef HAVE_MSG_SELECT
 int i;
+int active;
 SELECT_TYPE temp_mask = input_wait_mask;
 EMACS_TIME sometime;
 EMACS_SELECT_TIME select_time_to_block, *pointer_to_this;
 if (badly_p)
 	}
 else
 	{
 	  assert(0);
 	}
-#else
+#else /* not HAVE_MSG_SELECT */
 /* Now try getting a message or process event */
+DWORD active;
 DWORD what_events;
 if (mswindows_in_modal_loop)
 	/* In a modal loop, only look for timer events, and only if
 	   we really need one. */
 	{
 		/* Have to return something: there may be no accompanying
 		   process event */
 		mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
 	    }
 	}
-#endif
+#endif /* not HAVE_MSG_SELECT */
 } /* while */
 }
 /************************************************************************/
 /*                           Event generators                           */
 Lisp_Object emacs_event = Qnil;
 Lisp_Object fobj = Qnil;
 Lisp_Event *event;
 struct frame *frame;
-struct mswindows_frame* msframe;
+struct mswindows_frame *msframe;
 /* If you hit this, rewrite the offending API call to occur after GC,
 using register_post_gc_action(). */
 assert (!gc_in_progress);
 	    while (PeekMessage (&tranmsg, hwnd, WM_CHAR, WM_CHAR, PM_REMOVE)
 		   || PeekMessage (&tranmsg, hwnd, WM_SYSCHAR, WM_SYSCHAR,
 				   PM_REMOVE))
 	      {
 		int mods_with_quit = mods;
-		WPARAM ch = tranmsg.wParam;
+		Emchar ch = (Emchar) tranmsg.wParam;
 #ifdef DEBUG_XEMACS
 		if (debug_mswindows_events)
 		  {
 		    stderr_out ("-> ");
 					 Qcancel_mode_internal, Qnil);
 break;
 case WM_NOTIFY:
 {
-	LPNMHDR nmhdr = (LPNMHDR)lParam;
+	LPNMHDR nmhdr = (LPNMHDR) lParam;
-	if (nmhdr->code ==  TTN_NEEDTEXT)
+	if ((int) nmhdr->code == TTN_NEEDTEXT)
 	  {
 #ifdef HAVE_TOOLBARS
-	    LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT)lParam;
+	    LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT) lParam;
 	    Lisp_Object btext;
 	    /* find out which toolbar */
 	    frame = XFRAME (mswindows_find_frame (hwnd));
-	    btext = mswindows_get_toolbar_button_text ( frame,
+	    btext = mswindows_get_toolbar_button_text (frame, nmhdr->idFrom);
-							nmhdr->idFrom );
 	    tttext->lpszText = NULL;
 	    tttext->hinst = NULL;
 	    if (!NILP(btext))
 		LISP_STRING_TO_EXTERNAL (btext, tttext->lpszText, Qnative);
 	      }
 #endif
 	  }
 	/* handle tree view callbacks */
-	else if (nmhdr->code == TVN_SELCHANGED)
+	else if ((int) nmhdr->code == TVN_SELCHANGED)
 	  {
-	    NM_TREEVIEW* ptree = (NM_TREEVIEW*)lParam;
+	    NM_TREEVIEW *ptree = (NM_TREEVIEW *) lParam;
 	    frame = XFRAME (mswindows_find_frame (hwnd));
 	    mswindows_handle_gui_wm_command (frame, 0, ptree->itemNew.lParam);
 	  }
 	/* handle tab control callbacks */
-	else if (nmhdr->code == TCN_SELCHANGE)
+	else if ((int) nmhdr->code == TCN_SELCHANGE)
 	  {
 	    TC_ITEM item;
 	    int idx = SendMessage (nmhdr->hwndFrom, TCM_GETCURSEL, 0, 0);
 	    frame = XFRAME (mswindows_find_frame (hwnd));
 if (xGetKeyboardLayout) /* not in NT 3.5 */
 current_hkl = xGetKeyboardLayout (0);
 if (current_hkl != last_hkl)
 {
-TCHAR c;
+int c;
 last_hkl_has_AltGr = 0;
 /* In this loop, we query whether a character requires
 	 AltGr to be down to generate it. If at least such one
 	 found, this means that the layout does regard AltGr */
-for (c = ' '; c <= 0xFFU && c != 0 && !last_hkl_has_AltGr; ++c)
+for (c = ' '; c <= 255 && !last_hkl_has_AltGr; ++c)
-	if (HIBYTE (VkKeyScan (c)) == 6)
+	/* #### This is not really such a good check.  What about under
+	   CJK locales?  It may not matter there, though.  We always
+	   call VkKeyScanA so that we check the locale-specific characters
+	   in non-Latin-1 locales, instead of just the Latin-1 characters. */
+	if (HIBYTE (VkKeyScanA ((char) c)) == 6)
 	  last_hkl_has_AltGr = 1;
 last_hkl = current_hkl;
 }
 return last_hkl_has_AltGr;
 }
 char *str = 0;
 /* struct mswin_message_debug *i_hate_cranking_out_code_like_this; */
 for (i = 0; i < countof (debug_mswin_messages); i++)
 {
-if (debug_mswin_messages[i].mess == message_)
+if (debug_mswin_messages[i].mess == (int) message_)
 	{
 	  str = debug_mswin_messages[i].string;
 	  break;
 	}
 }

Mercurial > hg > xemacs-beta

comparison src/event-msw.c @ 647:b39c14581166