Checks if a point is visible on any monitor.
173662
def isPointVisible(self, x, y):
        
        class POINT(ctypes.Structure):
            _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
        pt = POINT()
        pt.x = x
        pt.y = y
        MONITOR_DEFAULTTONULL = 0
        hmon = self._user32.MonitorFromPoint(pt, MONITOR_DEFAULTTONULL)
        if hmon == 0:
            return False
        return True
594707
def contains_point( self, x, y ):
    """"""
    return ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0
803399
def is_point(self):
        

        if self.childCount() == 2:
                if self.child(0).valid_values == float and self.child(1).valid_values == float:
                    return True
        else:
            return False
441341
def isVisible(self, instance, mode='view', default=None, field=None):
        
        vis = super(RejectionWidget, self).isVisible(
            instance=instance, mode=mode, default=default, field=field)
        if instance.bika_setup.isRejectionWorkflowEnabled():
            return vis
        else:
            return 'invisible'
843545
def visible(self):
        
        query_results = self.map(lambda el: el.is_displayed(), 'visible').results
        if query_results:
            return all(query_results)
        return False
744737
function isVisiblePoint(point) {
  if (isText(point.node) || !hasChildren(point.node) || isEmpty(point.node)) {
    return true;
  }

  const leftNode = point.node.childNodes[point.offset - 1];
  const rightNode = point.node.childNodes[point.offset];
  if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode))) {
    return true;
  }

  return false;
}
230167
function containsPoint(x, y) {
         return x >= this.left && x <= this.right && y >= this.top && y <= this.bottom;
       }
109537
def contains_point?(pt)
      pt.x.between?(left, left + width - 1) &&
        pt.y.between?(top, top + height - 1)
    end
1356126
private boolean checkPoint(int mx, int my, ControlPoint pt) {
		int dx = (int) Math.abs((10+(width * pt.pos)) - mx);
		int dy = Math.abs((y+barHeight+7)-my);
		
		if ((dx < 5) && (dy < 7)) {
			return true;
		}
		
		return false;
	}
1342224
void setSystemCursorVisible(boolean visible)
    {
        if (screen == null)
        {
            cursorVisibility = Boolean.valueOf(visible);
        }
        else
        {
            if (visible)
            {
                screen.showCursor();
            }
            else
            {
                screen.hideCursor();
            }
        }
    }
432335
def visible(self, visible):
        """"""
        self._visible = visible

        if visible and len(self.panel.objects) == 0:
            self.setup()
            self.select.visible = True
            self.control_panel.extend(self.controls)
            self.panel.extend(self.children)
        elif not visible and len(self.panel.objects) > 0:
            self.unwatch()
            # do children
            self.select.visible = False
            self.control_panel.clear()
            self.search.visible = False
            self.add.visible = False
            self.panel.clear()
        if self.visible_callback:
            self.visible_callback(visible)
1029537
private static boolean multiPointContainsPoint_(MultiPoint multipoint_a,
			Point point_b, double tolerance, ProgressTracker progress_tracker) {
		return !multiPointDisjointPoint_(multipoint_a, point_b, tolerance,
				progress_tracker);
	}
532429
def _checkMousePositionForFocus(self):
        """"""
        i = 0
        cur_pos = pygame.mouse.get_pos()
        ml, mt = self.position
        for o in self.options:
            rect = o.get('label_rect')
            if rect:
                if rect.collidepoint(cur_pos) and self.mouse_pos != cur_pos:
                    self.option = i
                    self.mouse_pos = cur_pos
                    break
            i += 1
1174153
def isVisible(self, instance, mode='view', default="visible", field=None):
    
    # Emulate Products.Archetypes.Widget.TypesWidget#isVisible first
    vis_dic = getattr(aq_base(self), 'visible', _marker)
    state = default
    if vis_dic is _marker:
        return state
    if type(vis_dic) is DictType:
        state = vis_dic.get(mode, state)
    elif not vis_dic:
        state = 'invisible'
    elif vis_dic < 0:
        state = 'hidden'

    # Our custom code starts here
    if not field:
        return state

    # Look for visibility from the adapters provided by IATWidgetVisibility
    adapters = sorted(getAdapters([instance], IATWidgetVisibility),
                      key=lambda adapter: getattr(adapter[1], "sort", 1000),
                      reverse=True)
    for adapter_name, adapter in adapters:
        if field.getName() not in getattr(adapter, "field_names", []):
            # Omit those adapters that are not suitable for this field
            continue
        adapter_state = adapter(instance, mode, field, state)
        adapter_name = adapter.__class__.__name__
        logger.info("IATWidgetVisibility rule {} for {}.{} ({}): {} -> {}"
            .format(adapter_name, instance.id, field.getName(), mode, state,
                    adapter_state))
        if adapter_state == state:
            continue
        return adapter_state

    return state
147529
def _set_visible(self, visibility, grid_index=None):
        """"""

        if grid_index is None:
            for ax in self.flat_grid:
                ax.set_visible(visibility)
        else:
            if grid_index < 0 or grid_index >= len(self.grids):
                raise IndexError('Valid indices : 0 to {}'.format(len(self.grids) - 1))
            for ax in self.grids[grid_index]:
                ax.set_visible(visibility)
374243
boolean isVisible() {
        List<? extends Run<?, ?>> builds = currentProject.getBuilds();
        for (Run run : builds) {
            if (run.getAction(PerformanceJobReportAction.class) != null) {
                return true;
            }
        }
        return false;
    }
1236645
def isVisible( self ):
        
        layer = self.layer()
        if layer and not layer.isVisible():
            return False
        
        return self._visible