static gboolean
hippo_window_gtk_expose_event(GtkWidget *widget,
GdkEventExpose *event)
{
/* We don't want to redraw between requesting a new position/size
* from the window manager and getting allocated that size because
* we won't yet have made all the reallocations for the new size,
* but may already have the new coordinates after the resize. We
* count here on a) the resize not being denied by the window manager
* b) on the complete redraw we currently do at each new size.
*/
if (GTK_WINDOW(widget)->configure_request_count > 0)
return FALSE;
/* Ignoring the expose event while we are waiting for the window manager
* to resize us would cause problems if we were normally double-buffered
* because when we ignored the expose event, a blank double-buffer would
* get drawn. So what we do is turn off double-buffering at the widget
* level and do it ourselves here.
*/
gdk_window_begin_paint_region(widget->window, event->region);
GTK_WIDGET_CLASS(hippo_window_gtk_parent_class)->expose_event(widget, event);
gdk_window_end_paint(widget->window);
return FALSE;
}
static VALUE
rg_begin_paint(VALUE self, VALUE area)
{
if (rb_obj_is_kind_of(area, GTYPE2CLASS(GDK_TYPE_RECTANGLE))){
gdk_window_begin_paint_rect(_SELF(self),
RVAL2GDKRECTANGLE(area));
} else {
gdk_window_begin_paint_region(_SELF(self), RVAL2CRREGION(area));
}
return self;
}
static VALUE
gdkwin_begin_paint(VALUE self, VALUE area)
{
if (rb_obj_is_kind_of(area, GTYPE2CLASS(GDK_TYPE_RECTANGLE))){
gdk_window_begin_paint_rect(_SELF(self),
(GdkRectangle*)RVAL2BOXED(area, GDK_TYPE_RECTANGLE));
} else {
gdk_window_begin_paint_region(_SELF(self),
(GdkRegion*)RVAL2BOXED(area, GDK_TYPE_REGION));
}
return self;
}
void refresh_display(void)
{
int n;
scope_disp_t *disp;
scope_vert_t *vert;
scope_horiz_t *horiz;
int depth;
double pixels_per_div, pixels_per_sec, overall_record_length;
double screen_center_time, screen_start_time, screen_end_time;
/* cancel any pending refresh request */
ctrl_usr->display_refresh_timer = 0;
/* set pointers */
disp = &(ctrl_usr->disp);
vert = &(ctrl_usr->vert);
horiz = &(ctrl_usr->horiz);
/* get window pointer */
disp->win = disp->drawing->window;
if (disp->win == NULL) {
/* window isn't visible yet, do nothing */
printf("refresh_display(): win = NULL, bailing!\n");
return;
}
/* create drawing context if needed */
if (disp->context == NULL) {
disp->context = gdk_gc_new(disp->win);
}
/* get window dimensions */
gdk_window_get_geometry(disp->win, NULL, NULL, &(disp->width),
&(disp->height), &depth);
/* calculate horizontal params that depend on width */
pixels_per_div = disp->width * 0.1;
pixels_per_sec = pixels_per_div / horiz->disp_scale;
disp->pixels_per_sample = pixels_per_sec * horiz->sample_period;
overall_record_length = horiz->sample_period * ctrl_shm->rec_len;
screen_center_time = overall_record_length * horiz->pos_setting;
screen_start_time = screen_center_time - (5.0 * horiz->disp_scale);
disp->horiz_offset = screen_start_time * pixels_per_sec;
disp->start_sample = screen_start_time / horiz->sample_period;
if (disp->start_sample < 0) {
disp->start_sample = 0;
}
screen_end_time = screen_center_time + (5.0 * horiz->disp_scale);
disp->end_sample = (screen_end_time / horiz->sample_period) + 1;
if (disp->end_sample > ctrl_shm->rec_len - 1) {
disp->end_sample = ctrl_shm->rec_len - 1;
}
{
GdkRectangle rect = {0, 0, disp->width, disp->height};
GdkRegion *region = gdk_region_rectangle(&rect);
gdk_window_begin_paint_region(disp->drawing->window, region);
gdk_region_destroy(region);
}
DRAWING = 1;
clear_display_window();
draw_grid();
/* calculate offsets for AC-offset channels */
for (n = 0; n < 16; n++) {
if (vert->chan_enabled[n]) calculate_offset(n);
}
/* draw baselines first */
for (n = 0; n < 16; n++) {
if ((vert->chan_enabled[n]) && (n + 1 != vert->selected)) {
draw_baseline(n + 1, FALSE);
}
}
if (vert->chan_enabled[vert->selected - 1]) {
draw_baseline(vert->selected, TRUE);
}
/* Draw trigger line */
if (vert->chan_enabled[ctrl_shm->trig_chan - 1]) {
draw_triggerline(ctrl_shm->trig_chan,
ctrl_shm->trig_chan == vert->selected);
}
conflict_reset(disp->height);
/* draw non-highlighted waveforms next */
for (n = 0; n < 16; n++) {
if ((vert->chan_enabled[n]) && (vert->data_offset[n] >= 0)
&& (n + 1 != vert->selected)) {
draw_waveform(n + 1, FALSE);
}
}
/* draw highlighted waveform last */
if ((vert->chan_enabled[vert->selected - 1])
&& (vert->data_offset[vert->selected - 1] >= 0)) {
draw_waveform(vert->selected, TRUE);
}
update_readout();
gdk_window_end_paint(disp->drawing->window);
}
void FrameGdk::handleGdkEvent(GdkEvent* event)
{
switch (event->type) {
case GDK_EXPOSE: {
GdkRectangle clip;
gdk_region_get_clipbox(event->expose.region, &clip);
gdk_window_begin_paint_region (event->any.window, event->expose.region);
cairo_t* cr = gdk_cairo_create (event->any.window);
GraphicsContext* ctx = new GraphicsContext(cr);
paint(ctx, IntRect(clip.x, clip.y, clip.width, clip.height));
delete ctx;
gdk_window_end_paint (event->any.window);
break;
}
case GDK_SCROLL: {
PlatformWheelEvent wheelEvent(event);
view()->handleWheelEvent(wheelEvent);
if (wheelEvent.isAccepted()) {
return;
}
RenderObject::NodeInfo nodeInfo(true, true);
renderer()->layer()->hitTest(nodeInfo, wheelEvent.pos());
Node* node = nodeInfo.innerNode();
if (!node)
return;
//Default to scrolling the page
//not sure why its null
//broke anyway when its not null
doScroll(renderer(), wheelEvent.isHorizontal(), wheelEvent.delta());
break;
}
case GDK_DRAG_ENTER:
case GDK_DRAG_LEAVE:
case GDK_DRAG_MOTION:
case GDK_DRAG_STATUS:
case GDK_DROP_START:
case GDK_DROP_FINISHED: {
//bool updateDragAndDrop(const PlatformMouseEvent&, Clipboard*);
//void cancelDragAndDrop(const PlatformMouseEvent&, Clipboard*);
//bool performDragAndDrop(const PlatformMouseEvent&, Clipboard*);
break;
}
case GDK_MOTION_NOTIFY:
view()->handleMouseMoveEvent(event);
break;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
view()->handleMousePressEvent(event);
break;
case GDK_BUTTON_RELEASE:
view()->handleMouseReleaseEvent(event);
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE: {
PlatformKeyboardEvent kevent(event);
bool handled = false;
if (!kevent.isKeyUp()) {
Node* start = selection().start().node();
if (start && start->isContentEditable()) {
switch(kevent.WindowsKeyCode()) {
case VK_BACK:
TypingCommand::deleteKeyPressed(document());
break;
case VK_DELETE:
TypingCommand::forwardDeleteKeyPressed(document());
break;
case VK_LEFT:
selection().modify(SelectionController::MOVE, SelectionController::LEFT, CharacterGranularity);
break;
case VK_RIGHT:
selection().modify(SelectionController::MOVE, SelectionController::RIGHT, CharacterGranularity);
break;
case VK_UP:
selection().modify(SelectionController::MOVE, SelectionController::BACKWARD, ParagraphGranularity);
break;
case VK_DOWN:
selection().modify(SelectionController::MOVE, SelectionController::FORWARD, ParagraphGranularity);
break;
default:
TypingCommand::insertText(document(), kevent.text(), false);
}
handled = true;
}
if (!handled) {
switch (kevent.WindowsKeyCode()) {
case VK_LEFT:
doScroll(renderer(), true, -120);
break;
case VK_RIGHT:
doScroll(renderer(), true, 120);
break;
case VK_UP:
doScroll(renderer(), false, -120);
break;
case VK_PRIOR:
//return SB_PAGEUP;
break;
case VK_NEXT:
//return SB_PAGEDOWN;
break;
case VK_DOWN:
doScroll(renderer(), false, 120);
break;
case VK_HOME:
renderer()->layer()->scrollToOffset(0, 0, true, true);
doScroll(renderer(), false, 120);
break;
case VK_END:
renderer()->layer()->scrollToOffset(0,
renderer()->height(), true, true);
break;
case VK_SPACE:
if (kevent.shiftKey())
doScroll(renderer(), false, -120);
else
doScroll(renderer(), false, 120);
break;
}
}
}
}
default:
break;
}
}
