/* Timer ID used for button2 emulation */
#define BUTTON_2_TIMER_ID 1
-extern Lisp_Object
+extern Lisp_Object
mswindows_get_toolbar_button_text (struct frame* f, int command_id);
extern Lisp_Object
mswindows_handle_toolbar_wm_command (struct frame* f, HWND ctrl, WORD id);
};
#define MAX_SLURP_STREAMS 32
-struct ntpipe_slurp_stream_shared_data
+struct ntpipe_slurp_stream_shared_data
shared_data_block[MAX_SLURP_STREAMS]={{0}};
struct ntpipe_slurp_stream
/* Now we got something to notify caller, either a byte or an
error/eof indication. Before we do, allow internal pipe
- buffer to accumulate little bit more data.
+ buffer to accumulate little bit more data.
Reader function pulses this event before waiting for
a character, to avoid pipe delay, and to get the byte
immediately. */
return s->thread_data->hev_caller;
}
-static int
+static ssize_t
ntpipe_slurp_reader (Lstream *stream, unsigned char *data, size_t size)
{
/* This function must be called from the main thread only */
- struct ntpipe_slurp_stream_shared_data* s =
+ struct ntpipe_slurp_stream_shared_data* s =
NTPIPE_SLURP_STREAM_DATA(stream)->thread_data;
if (!s->die_p)
/* Disallow pipe read delay for the thread: we need a character
ASAP */
SetEvent (s->hev_unsleep);
-
+
/* Check if we have a character ready. Give it a short delay,
for the thread to awake from pipe delay, just ion case*/
wait_result = WaitForSingleObject (s->hev_caller, 2);
ReadFile (s->hpipe, data, min (bytes_available, size),
&bytes_read, NULL);
}
-
+
/* Now we can unblock thread, so it attempts to read more */
SetEvent (s->hev_thread);
return bytes_read + 1;
return 0;
}
-static int
+static int
ntpipe_slurp_closer (Lstream *stream)
{
/* This function must be called from the main thread only */
- struct ntpipe_slurp_stream_shared_data* s =
+ struct ntpipe_slurp_stream_shared_data* s =
NTPIPE_SLURP_STREAM_DATA(stream)->thread_data;
/* Force thread to stop */
LSTREAM_TYPE_DATA (stream, ntpipe_shove)
#define MAX_SHOVE_BUFFER_SIZE 128
-
+
struct ntpipe_shove_stream
{
LPARAM user_data; /* Any user data stored in the stream object */
for (;;)
{
- DWORD bytes_written;
+ DWORD bytes_written;
/* Block on event and wait for a job */
InterlockedIncrement (&s->idle_p);
s->hpipe = hpipe;
s->user_data = param;
- /* Create reader thread. This could fail, so do not
+ /* Create reader thread. This could fail, so do not
create the event until thread is created */
s->hthread = CreateThread (NULL, 0, shove_thread, (LPVOID)s,
CREATE_SUSPENDED, &thread_id_unused);
}
#endif
-static int
+static ssize_t
ntpipe_shove_writer (Lstream *stream, const unsigned char *data, size_t size)
{
struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
str->eof_p = 1;
}
-static int
+static ssize_t
winsock_reader (Lstream *stream, unsigned char *data, size_t size)
{
struct winsock_stream *str = WINSOCK_STREAM_DATA (stream);
return 0;
if (str->error_p)
return -1;
-
+
/* Return as much of buffer as we have */
size = min (size, (size_t) (str->bufsize - str->bufpos));
memcpy (data, (void*)((BYTE*)str->buffer + str->bufpos), size);
return size;
}
-static int
+static ssize_t
winsock_writer (Lstream *stream, CONST unsigned char *data, size_t size)
{
struct winsock_stream *str = WINSOCK_STREAM_DATA (stream);
if (size == 0)
return 0;
-
+
{
ResetEvent (str->ov.hEvent);
|| sevt->event_type == misc_user_event);
}
-/*
+/*
* Add an emacs event to the proper dispatch queue
*/
static void
{
int user_p = mswindows_user_event_p (XEVENT(event));
enqueue_event (event,
- user_p ? &mswindows_u_dispatch_event_queue :
+ user_p ? &mswindows_u_dispatch_event_queue :
&mswindows_s_dispatch_event_queue,
user_p ? &mswindows_u_dispatch_event_queue_tail :
&mswindows_s_dispatch_event_queue_tail);
event->event.button.x = where.x;
event->event.button.y = where.y;
event->event.button.modifiers = mswindows_modifier_state (NULL, 0);
-
+
if (message==WM_LBUTTONDOWN || message==WM_MBUTTONDOWN ||
message==WM_RBUTTONDOWN)
{
event->event_type = button_release_event;
ReleaseCapture ();
}
-
+
mswindows_enqueue_dispatch_event (emacs_event);
}
!NILP(mswindows_s_dispatch_event_queue));
event = dequeue_event (
- NILP(mswindows_u_dispatch_event_queue) ?
- &mswindows_s_dispatch_event_queue :
+ NILP(mswindows_u_dispatch_event_queue) ?
+ &mswindows_s_dispatch_event_queue :
&mswindows_u_dispatch_event_queue,
- NILP(mswindows_u_dispatch_event_queue) ?
+ NILP(mswindows_u_dispatch_event_queue) ?
&mswindows_s_dispatch_event_queue_tail :
&mswindows_u_dispatch_event_queue_tail);
Lisp_Object event;
Lisp_Object previous_event = Qnil;
int user_p = mswindows_user_event_p (match);
- Lisp_Object* head = user_p ? &mswindows_u_dispatch_event_queue :
+ Lisp_Object* head = user_p ? &mswindows_u_dispatch_event_queue :
&mswindows_s_dispatch_event_queue;
- Lisp_Object* tail = user_p ? &mswindows_u_dispatch_event_queue_tail :
+ Lisp_Object* tail = user_p ? &mswindows_u_dispatch_event_queue_tail :
&mswindows_s_dispatch_event_queue_tail;
assert (match->event_type == timeout_event
if (EQ (*tail, event))
*tail = previous_event;
}
-
+
return event;
}
previous_event = event;
if (ix < 0)
return;
- mswindows_waitable_handles [ix] =
+ mswindows_waitable_handles [ix] =
mswindows_waitable_handles [--mswindows_waitable_count];
}
#endif /* HAVE_MSG_SELECT */
{
Lisp_Object tmp;
- ++mswindows_in_modal_loop;
+ ++mswindows_in_modal_loop;
tmp = condition_case_1 (Qt,
bfun, barg,
mswindows_modal_loop_error_handler, Qnil);
}
/*
- * This is an unsafe part of event pump, guarded by
+ * This is an unsafe part of event pump, guarded by
* condition_case. See mswindows_pump_outstanding_events
*/
static Lisp_Object
Fdeallocate_event (event);
UNGCPRO;
-
+
/* Qt becomes return value of mswindows_pump_outstanding_events
once we get here */
return Qt;
Lisp_Object result = Qt;
struct gcpro gcpro1;
GCPRO1 (result);
-
+
if (NILP(mswindows_error_caught_in_modal_loop))
result = mswindows_protect_modal_loop (mswindows_unsafe_pump_events, Qnil);
UNGCPRO;
return result;
}
-static void
+static void
mswindows_drain_windows_queue ()
{
MSG msg;
}
}
-/*
+/*
* This is a special flavor of the mswindows_need_event function,
* used while in event pump. Actually, there is only kind of events
* allowed while in event pump: a timer. An attempt to fetch any
/* We'll deadlock if go waiting */
if (mswindows_pending_timers_count == 0)
error ("Deadlock due to an attempt to call next-event in a wrong context");
-
+
/* Fetch and dispatch any pending timers */
GetMessage (&msg, NULL, WM_TIMER, WM_TIMER);
DispatchMessage (&msg);
SELECT_TYPE temp_mask = input_wait_mask;
EMACS_TIME sometime;
EMACS_SELECT_TIME select_time_to_block, *pointer_to_this;
-
+
if (badly_p)
pointer_to_this = 0;
else
}
active = select (MAXDESC, &temp_mask, 0, 0, pointer_to_this);
-
+
if (active == 0)
{
assert (!badly_p);
{
mswindows_drain_windows_queue ();
}
-#ifdef HAVE_TTY
+#ifdef HAVE_TTY
/* Look for a TTY event */
for (i = 0; i < MAXDESC-1; i++)
{
struct console *c = tty_find_console_from_fd (i);
Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
struct Lisp_Event* event = XEVENT (emacs_event);
-
+
assert (c);
if (read_event_from_tty_or_stream_desc (event, c, i))
{
{
struct Lisp_Process *p =
get_process_from_usid (FD_TO_USID(i));
-
+
mswindows_enqueue_process_event (p);
}
else
assert ((!badly_p && active == WAIT_TIMEOUT) ||
(active >= WAIT_OBJECT_0 &&
active <= WAIT_OBJECT_0 + mswindows_waitable_count));
-
+
if (active == WAIT_TIMEOUT)
{
/* No luck trying - just return what we've already got */
{
int ix = active - WAIT_OBJECT_0;
/* First, try to find which process' output has signaled */
- struct Lisp_Process *p =
+ struct Lisp_Process *p =
get_process_from_usid (HANDLE_TO_USID (mswindows_waitable_handles[ix]));
if (p != NULL)
{
/* Event generators */
/************************************************************************/
-/*
+/*
* Callback procedure for synchronous timer messages
*/
static void CALLBACK
mswindows_enqueue_dispatch_event (emacs_event);
}
-/*
+/*
* Callback procedure for dde messages
*
* We execute a dde Open("file") by simulating a file drop, so dde support
mswindows_dde_callback (UINT uType, UINT uFmt, HCONV hconv,
HSZ hszTopic, HSZ hszItem, HDDEDATA hdata,
DWORD dwData1, DWORD dwData2)
-{
+{
switch (uType)
- {
+ {
case XTYP_CONNECT:
if (!DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system))
return (HDDEDATA)TRUE;
return (DdeCreateDataHandle (mswindows_dde_mlid, (LPBYTE)pairs,
sizeof (pairs), 0L, 0, uFmt, 0));
}
- return (HDDEDATA)NULL;
+ return (HDDEDATA)NULL;
case XTYP_EXECUTE:
if (!DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system))
UNGCPRO;
return (HDDEDATA) DDE_FACK;
}
- DdeFreeDataHandle (hdata);
+ DdeFreeDataHandle (hdata);
return (HDDEDATA) DDE_FNOTPROCESSED;
- default:
- return (HDDEDATA) NULL;
- }
+ default:
+ return (HDDEDATA) NULL;
+ }
}
#endif
BYTE keymap_orig[256];
POINT pnt = { LOWORD (GetMessagePos()), HIWORD (GetMessagePos()) };
MSG msg;
-
+
msg.hwnd = hwnd;
msg.message = message;
msg.wParam = wParam;
mswindows_enqueue_mouse_button_event (hwnd, message,
MAKEPOINTS (lParam), GetMessageTime());
break;
-
+
case WM_LBUTTONUP:
msframe = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
msframe->last_click_time = GetMessageTime();
}
msframe->last_click_time = GetMessageTime();
break;
-
+
case WM_TIMER:
if (wParam == BUTTON_2_TIMER_ID)
{
event->event.motion.x = MAKEPOINTS(lParam).x;
event->event.motion.y = MAKEPOINTS(lParam).y;
event->event.motion.modifiers = mswindows_modifier_state (NULL, 0);
-
+
mswindows_enqueue_dispatch_event (emacs_event);
}
break;
/* 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 );
-
+
tttext->lpszText = NULL;
tttext->hinst = NULL;
{
/* I think this is safe since the text will only go away
when the toolbar does...*/
- GET_C_STRING_EXT_DATA_ALLOCA (btext, FORMAT_OS,
+ GET_C_STRING_EXT_DATA_ALLOCA (btext, FORMAT_OS,
tttext->lpszText);
}
#endif
item.mask = TCIF_PARAM;
SendMessage (nmhdr->hwndFrom, TCM_GETITEM, (WPARAM)index,
(LPARAM)&item);
-
+
mswindows_handle_gui_wm_command (frame, 0, item.lParam);
}
}
break;
-
+
case WM_PAINT:
{
/* According to the docs we need to check GetUpdateRect() before
int x, y, width, height;
frame = XFRAME (mswindows_find_frame (hwnd));
-
+
BeginPaint (hwnd, &paintStruct);
x = paintStruct.rcPaint.left;
y = paintStruct.rcPaint.top;
if (FRAME_MSWINDOWS_TARGET_RECT (frame))
{
/* Yes, we have to size again */
- mswindows_size_frame_internal ( frame,
- FRAME_MSWINDOWS_TARGET_RECT
+ mswindows_size_frame_internal ( frame,
+ FRAME_MSWINDOWS_TARGET_RECT
(frame));
/* Reset so we do not get here again. The SetWindowPos call in
* mswindows_size_frame_internal can cause recursion here. */
if (!msframe->sizing && !FRAME_VISIBLE_P (frame))
mswindows_enqueue_magic_event (hwnd, XM_MAPFRAME);
FRAME_VISIBLE_P (frame) = 1;
-
+
if (!msframe->sizing || mswindows_dynamic_frame_resize)
redisplay ();
}
SendMessage (hwndScrollBar, WM_CANCELMODE, 0, 0);
}
UNGCPRO;
- break;
+ break;
}
case WM_MOUSEWHEEL:
}
else
goto defproc;
- break;
+ break;
}
#endif
Lisp_Object image_instance;
VOID_TO_LISP (image_instance, ii);
if (IMAGE_INSTANCEP (image_instance)
- &&
+ &&
IMAGE_INSTANCE_TYPE_P (image_instance, IMAGE_WIDGET)
&&
!NILP (XIMAGE_INSTANCE_WIDGET_FACE (image_instance)))
{
if (widget_brush)
DeleteObject (widget_brush);
- widget_brush = CreateSolidBrush
- (COLOR_INSTANCE_MSWINDOWS_COLOR
- (XCOLOR_INSTANCE
- (FACE_BACKGROUND
+ widget_brush = CreateSolidBrush
+ (COLOR_INSTANCE_MSWINDOWS_COLOR
+ (XCOLOR_INSTANCE
+ (FACE_BACKGROUND
(XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
XIMAGE_INSTANCE_SUBWINDOW_FRAME (image_instance)))));
}
last_widget_brushed = ii;
SetTextColor
(hdc,
- COLOR_INSTANCE_MSWINDOWS_COLOR
- (XCOLOR_INSTANCE
- (FACE_FOREGROUND
+ COLOR_INSTANCE_MSWINDOWS_COLOR
+ (XCOLOR_INSTANCE
+ (FACE_FOREGROUND
(XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
XIMAGE_INSTANCE_SUBWINDOW_FRAME (image_instance)))));
SetBkMode (hdc, OPAQUE);
SetBkColor
(hdc,
- COLOR_INSTANCE_MSWINDOWS_COLOR
- (XCOLOR_INSTANCE
- (FACE_BACKGROUND
+ COLOR_INSTANCE_MSWINDOWS_COLOR
+ (XCOLOR_INSTANCE
+ (FACE_BACKGROUND
(XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
XIMAGE_INSTANCE_SUBWINDOW_FRAME (image_instance)))));
return (LRESULT)widget_brush;
{
case XM_BUMPQUEUE:
break;
-
+
case WM_SETFOCUS:
case WM_KILLFOCUS:
{
case XM_UNMAPFRAME:
{
Lisp_Object frame = EVENT_CHANNEL (emacs_event);
- va_run_hook_with_args (EVENT_MSWINDOWS_MAGIC_TYPE(emacs_event)
+ va_run_hook_with_args (EVENT_MSWINDOWS_MAGIC_TYPE(emacs_event)
== XM_MAPFRAME ?
- Qmap_frame_hook : Qunmap_frame_hook,
+ Qmap_frame_hook : Qunmap_frame_hook,
1, frame);
}
break;
-
+
/* #### What about Enter & Leave */
#if 0
va_run_hook_with_args (in_p ? Qmouse_enter_frame_hook :
mswindows_event_stream->select_console_cb = emacs_mswindows_select_console;
mswindows_event_stream->unselect_console_cb = emacs_mswindows_unselect_console;
#ifdef HAVE_MSG_SELECT
- mswindows_event_stream->select_process_cb =
+ mswindows_event_stream->select_process_cb =
(void (*)(struct Lisp_Process*))event_stream_unixoid_select_process;
- mswindows_event_stream->unselect_process_cb =
+ mswindows_event_stream->unselect_process_cb =
(void (*)(struct Lisp_Process*))event_stream_unixoid_unselect_process;
mswindows_event_stream->create_stream_pair_cb = event_stream_unixoid_create_stream_pair;
mswindows_event_stream->delete_stream_pair_cb = event_stream_unixoid_delete_stream_pair;
projects / chise / xemacs-chise.git.1 / blobdiff