static bool set_size_floating(int new_dimension, bool use_width) {
swayc_t *view = get_focused_float(swayc_active_workspace());
if (view) {
if (use_width) {
int current_width = view->width;
view->desired_width = new_dimension;
floating_view_sane_size(view);
int new_x = view->x + (int)(((view->desired_width - current_width) / 2) * -1);
view->width = view->desired_width;
view->x = new_x;
update_geometry(view);
} else {
int current_height = view->height;
view->desired_height = new_dimension;
floating_view_sane_size(view);
int new_y = view->y + (int)(((view->desired_height - current_height) / 2) * -1);
view->height = view->desired_height;
view->y = new_y;
update_geometry(view);
}
return true;
}
return false;
}
Surface::Surface():
_sType("void")
{
_pMaterial=0;
_pMaterialNext=0;
_pMaterialPrev=0;
_x=0.;
_y=0.;
_z=0.;
_dDiameter=0;
_dDiameter2=0;
_dInnerDiameter=0;
_dInnerDiameter2=0;
_bAutoDiameter=false;
_bAutoInnerDiameter=false;
_dConic=0.;
_dCurvature=0.;
_dR4=0.;
_dR6=0.;
_dR8=0.;
_dR10=0.;
_bIsPerfect=false;
update_geometry();
}
void
OrderedTaskPoint::update_oz(const TaskProjection &projection)
{
update_geometry();
SampledTaskPoint::update_oz(projection);
}
static void
csm_fail_whale_dialog_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
CsmFailWhaleDialog *fail_dialog;
GdkRectangle old_geometry;
int position_changed = FALSE;
int size_changed = FALSE;
fail_dialog = CSM_FAIL_WHALE_DIALOG (widget);
old_geometry = fail_dialog->priv->geometry;
update_geometry (fail_dialog);
requisition->width = fail_dialog->priv->geometry.width;
requisition->height = fail_dialog->priv->geometry.height;
if (!gtk_widget_get_realized (widget)) {
return;
}
if (old_geometry.width != fail_dialog->priv->geometry.width ||
old_geometry.height != fail_dialog->priv->geometry.height) {
size_changed = TRUE;
}
if (old_geometry.x != fail_dialog->priv->geometry.x ||
old_geometry.y != fail_dialog->priv->geometry.y) {
position_changed = TRUE;
}
_window_move_resize_window (fail_dialog,
position_changed, size_changed);
}
bool
OrderedTask::Replace(const OrderedTaskPoint &new_tp, const unsigned position)
{
if (position >= task_points.size())
return false;
if (task_points[position]->equals(&new_tp))
// nothing to do
return true;
/* is the new_tp allowed in this context? */
if ((position > 0 && !new_tp.predecessor_allowed()) ||
(position + 1 < task_points.size() && !new_tp.successor_allowed()))
return false;
delete task_points[position];
task_points[position] = new_tp.clone(task_behaviour, m_ordered_behaviour);
if (position)
set_neighbours(position - 1);
set_neighbours(position);
if (position + 1 < task_points.size())
set_neighbours(position + 1);
update_geometry();
return true;
}
bool
OrderedTask::Insert(const OrderedTaskPoint &new_tp, const unsigned position)
{
if (position >= task_points.size())
return Append(new_tp);
if (/* is the new_tp allowed in this context? */
(position > 0 && !new_tp.predecessor_allowed()) ||
!new_tp.successor_allowed() ||
/* can a tp be inserted at this position? */
(position > 0 && !task_points[position - 1]->successor_allowed()) ||
!task_points[position]->predecessor_allowed())
return false;
if (active_task_point >= position)
active_task_point++;
task_points.insert(task_points.begin() + position,
new_tp.clone(task_behaviour, m_ordered_behaviour));
if (position)
set_neighbours(position - 1);
set_neighbours(position);
set_neighbours(position + 1);
update_geometry();
return true;
}
const ts::Double_rect& ts::graphics::Text::bounds() const
{
if (geometry_.dirty)
{
update_geometry();
}
return geometry_.bounds;
}
const ts::graphics::Geometry& ts::graphics::Text::geometry() const
{
if (geometry_.dirty)
{
update_geometry();
}
return geometry_.geometry;
}
void
OrderedTaskPoint::set_neighbours(OrderedTaskPoint* _prev,
OrderedTaskPoint* _next)
{
tp_previous = _prev;
tp_next = _next;
update_geometry();
}
bool
OrderedTask::AppendOptionalStart(const OrderedTaskPoint &new_tp)
{
optional_start_points.push_back(new_tp.clone(task_behaviour, m_ordered_behaviour));
if (task_points.size() > 1)
set_neighbours(0);
update_geometry();
return true;
}
bool
OrderedTask::Commit(const OrderedTask& that)
{
bool modified = false;
// change mode to that one
SetFactory(that.factory_mode);
// copy across behaviour
m_ordered_behaviour = that.m_ordered_behaviour;
// remove if that task is smaller than this one
while (TaskSize() > that.TaskSize()) {
Remove(TaskSize() - 1);
modified = true;
}
// ensure each task point made identical
for (unsigned i = 0; i < that.TaskSize(); ++i) {
if (i >= TaskSize()) {
// that task is larger than this
Append(*that.task_points[i]);
modified = true;
} else if (!task_points[i]->equals(that.task_points[i])) {
// that task point is changed
Replace(*that.task_points[i], i);
modified = true;
}
}
// remove if that optional start list is smaller than this one
while (optional_start_points.size() > that.optional_start_points.size()) {
RemoveOptionalStart(optional_start_points.size() - 1);
modified = true;
}
// ensure each task point made identical
for (unsigned i = 0; i < that.optional_start_points.size(); ++i) {
if (i >= optional_start_points.size()) {
// that task is larger than this
AppendOptionalStart(*that.optional_start_points[i]);
modified = true;
} else if (!optional_start_points[i]->equals(that.optional_start_points[i])) {
// that task point is changed
ReplaceOptionalStart(*that.optional_start_points[i], i);
modified = true;
}
}
if (modified)
update_geometry();
// @todo also re-scan task sample state,
// potentially resetting task
return modified;
}
void
gst_v4l2_xoverlay_set_window_handle (GstV4l2Object * v4l2object, guintptr id)
{
GstV4l2Xv *v4l2xv;
XID xwindow_id = id;
gboolean change = (v4l2object->xwindow_id != xwindow_id);
GST_LOG_OBJECT (v4l2object->element, "Setting XID to %lx",
(gulong) xwindow_id);
if (!v4l2object->xv && GST_V4L2_IS_OPEN (v4l2object))
gst_v4l2_xoverlay_open (v4l2object);
v4l2xv = v4l2object->xv;
if (v4l2xv)
g_mutex_lock (v4l2xv->mutex);
if (change) {
if (v4l2object->xwindow_id && v4l2xv) {
GST_DEBUG_OBJECT (v4l2object->element,
"Deactivating old port %lx", v4l2object->xwindow_id);
XvSelectPortNotify (v4l2xv->dpy, v4l2xv->port, 0);
XvSelectVideoNotify (v4l2xv->dpy, v4l2object->xwindow_id, 0);
XvStopVideo (v4l2xv->dpy, v4l2xv->port, v4l2object->xwindow_id);
}
v4l2object->xwindow_id = xwindow_id;
}
if (!v4l2xv || xwindow_id == 0) {
if (v4l2xv)
g_mutex_unlock (v4l2xv->mutex);
return;
}
if (change) {
GST_DEBUG_OBJECT (v4l2object->element, "Activating new port %lx",
xwindow_id);
/* draw */
XvSelectPortNotify (v4l2xv->dpy, v4l2xv->port, 1);
XvSelectVideoNotify (v4l2xv->dpy, v4l2object->xwindow_id, 1);
}
update_geometry (v4l2object);
if (v4l2xv->idle_id)
g_source_remove (v4l2xv->idle_id);
v4l2xv->idle_id = g_idle_add (idle_refresh, v4l2object);
g_mutex_unlock (v4l2xv->mutex);
}
double ts::graphics::Text::base_line(std::size_t character_index) const
{
double base = line_height_;
if (geometry_.dirty)
{
update_geometry();
}
auto it = std::lower_bound(geometry_.line_breaks.begin(), geometry_.line_breaks.end(), character_index);
auto line_number = it - geometry_.line_breaks.begin();
return base + (base * line_number);
}
bool
OrderedTask::RemoveOptionalStart(const unsigned position)
{
if (position >= optional_start_points.size())
return false;
erase_optional_start(position);
if (task_points.size()>1)
set_neighbours(0);
update_geometry();
return true;
}
static void
csm_fail_whale_dialog_realize (GtkWidget *widget)
{
if (GTK_WIDGET_CLASS (csm_fail_whale_dialog_parent_class)->realize) {
GTK_WIDGET_CLASS (csm_fail_whale_dialog_parent_class)->realize (widget);
}
_window_override_user_time (CSM_FAIL_WHALE_DIALOG (widget));
update_geometry (CSM_FAIL_WHALE_DIALOG (widget));
_window_move_resize_window (CSM_FAIL_WHALE_DIALOG (widget), TRUE, TRUE);
g_signal_connect (gtk_window_get_screen (GTK_WINDOW (widget)),
"size_changed",
G_CALLBACK (on_screen_size_changed),
widget);
}
void configurenotify(XEvent *e)
{
dbg("configurenotify(): IN\n");
/* update screen width/height on root geom change */
XConfigureEvent *ev = &e->xconfigure;
if (ev->window == root) {
dbg("configurenotify(): \tROOT CHANGED\n");
sw = ev->width;
sh = ev->height;
update_geometry();
create_bar();
map_bar();
draw();
tile_current(0);
}
dbg("configurenotify(): OUT\n");
}
bool
OrderedTask::ReplaceOptionalStart(const OrderedTaskPoint &new_tp,
const unsigned position)
{
if (position >= optional_start_points.size())
return false;
if (optional_start_points[position]->equals(&new_tp))
// nothing to do
return true;
delete optional_start_points[position];
optional_start_points[position] = new_tp.clone(task_behaviour, m_ordered_behaviour);
set_neighbours(0);
update_geometry();
return true;
}
ts::Vector2<double> ts::graphics::Text::character_position(std::size_t index) const
{
if (geometry_.dirty)
{
update_geometry();
}
if (index >= geometry_.character_offsets.size())
{
return Vector2<double>();
}
Vector2<double> result;
result.x = geometry_.character_offsets[index];
result.y = base_line(index);
return result;
}
bool
OrderedTask::Remove(const unsigned position)
{
if (position >= task_points.size())
return false;
if (active_task_point > position ||
(active_task_point > 0 && active_task_point == task_points.size() - 1))
active_task_point--;
erase(position);
set_neighbours(position);
if (position)
set_neighbours(position - 1);
update_geometry();
return true;
}
void
OrderedTask::select_optional_start(unsigned pos)
{
assert(pos< optional_start_points.size());
// put task start onto end
optional_start_points.push_back(task_points[0]);
// set task start from top optional item
task_points[0] = optional_start_points[pos];
// remove top optional item from list
optional_start_points.erase(optional_start_points.begin()+pos);
// update neighbour links
set_neighbours(0);
if (task_points.size()>1)
set_neighbours(1);
// we've changed the task, so update geometry
update_geometry();
}
static gboolean
idle_refresh (gpointer data)
{
GstV4l2Object *v4l2object = GST_V4L2_OBJECT (data);
GstV4l2Xv *v4l2xv = v4l2object->xv;
GST_LOG_OBJECT (v4l2object->element, "idle refresh");
if (v4l2xv) {
g_mutex_lock (v4l2xv->mutex);
update_geometry (v4l2object);
v4l2xv->idle_id = 0;
g_mutex_unlock (v4l2xv->mutex);
}
/* once */
return FALSE;
}
bool
OrderedTask::Append(const OrderedTaskPoint &new_tp)
{
if (/* is the new_tp allowed in this context? */
(!task_points.empty() && !new_tp.predecessor_allowed()) ||
/* can a tp be appended after the last one? */
(task_points.size() >= 1 && !task_points[task_points.size() - 1]->successor_allowed()))
return false;
task_points.push_back(new_tp.clone(task_behaviour, m_ordered_behaviour));
if (task_points.size() > 1)
set_neighbours(task_points.size() - 2);
else {
// give it a value when we have one tp so it is not uninitialised
m_location_min_last = new_tp.GetLocation();
}
set_neighbours(task_points.size() - 1);
update_geometry();
return true;
}
void Surface::set_radius_curvature(double dRadiusCurvature)
{
_dCurvature=1./dRadiusCurvature;
update_geometry();
}
void pointer_mode_update(void) {
if (initial.ptr->type != C_VIEW) {
pointer_state.mode = 0;
return;
}
struct wlc_point origin;
wlc_pointer_get_position(&origin);
int dx = origin.x;
int dy = origin.y;
switch (pointer_state.mode) {
case M_FLOATING | M_DRAGGING:
// Update position
switch (config->dragging_key) {
case M_LEFT_CLICK:
dx -= pointer_state.left.x;
dy -= pointer_state.left.y;
break;
case M_RIGHT_CLICK:
dx -= pointer_state.right.x;
dy -= pointer_state.right.y;
break;
}
if (initial.x + dx != initial.ptr->x) {
initial.ptr->x = initial.x + dx;
}
if (initial.y + dy != initial.ptr->y) {
initial.ptr->y = initial.y + dy;
}
update_geometry(initial.ptr);
break;
case M_FLOATING | M_RESIZING:
switch (config->resizing_key) {
case M_LEFT_CLICK:
dx -= pointer_state.left.x;
dy -= pointer_state.left.y;
initial.ptr = pointer_state.left.view;
break;
case M_RIGHT_CLICK:
dx -= pointer_state.right.x;
dy -= pointer_state.right.y;
initial.ptr = pointer_state.right.view;
break;
}
if (lock.left) {
if (initial.w + dx > min_sane_w) {
initial.ptr->width = initial.w + dx;
}
} else { // lock.right
if (initial.w - dx > min_sane_w) {
initial.ptr->width = initial.w - dx;
initial.ptr->x = initial.x + dx;
}
}
if (lock.top) {
if (initial.h + dy > min_sane_h) {
initial.ptr->height = initial.h + dy;
}
} else { // lock.bottom
if (initial.h - dy > min_sane_h) {
initial.ptr->height = initial.h - dy;
initial.ptr->y = initial.y + dy;
}
}
update_geometry(initial.ptr);
break;
case M_TILING | M_DRAGGING:
// swap current view under pointer with dragged view
if (pointer_state.view && pointer_state.view->type == C_VIEW
&& pointer_state.view != initial.ptr
&& !pointer_state.view->is_floating) {
// Swap them around
swap_container(pointer_state.view, initial.ptr);
swap_geometry(pointer_state.view, initial.ptr);
update_geometry(pointer_state.view);
update_geometry(initial.ptr);
// Set focus back to initial view
set_focused_container(initial.ptr);
}
break;
case M_TILING | M_RESIZING:
switch (config->resizing_key) {
case M_LEFT_CLICK:
dx -= pointer_state.left.x;
dy -= pointer_state.left.y;
break;
case M_RIGHT_CLICK:
dx -= pointer_state.right.x;
dy -= pointer_state.right.y;
break;
}
// resize if we can
if (initial.horiz.ptr) {
if (lock.left) {
// Check whether its fine to resize
if (initial.w + dx > min_sane_w && initial.horiz.w - dx > min_sane_w) {
initial.horiz.ptr->width = initial.horiz.w - dx;
initial.horiz.parent.ptr->width = initial.horiz.parent.w + dx;
}
} else { // lock.right
if (initial.w - dx > min_sane_w && initial.horiz.w + dx > min_sane_w) {
initial.horiz.ptr->width = initial.horiz.w + dx;
initial.horiz.parent.ptr->width = initial.horiz.parent.w - dx;
}
}
arrange_windows(initial.horiz.ptr->parent, -1, -1);
}
if (initial.vert.ptr) {
if (lock.top) {
if (initial.h + dy > min_sane_h && initial.vert.h - dy > min_sane_h) {
initial.vert.ptr->height = initial.vert.h - dy;
initial.vert.parent.ptr->height = initial.vert.parent.h + dy;
}
} else { // lock.bottom
if (initial.h - dy > min_sane_h && initial.vert.h + dy > min_sane_h) {
initial.vert.ptr->height = initial.vert.h + dy;
initial.vert.parent.ptr->height = initial.vert.parent.h - dy;
}
}
arrange_windows(initial.vert.ptr->parent, -1, -1);
}
default:
return;
}
}
static void update_variables(void)
{
bool geometry_update = false;
char key[256];
struct retro_variable var;
var.key = "snes9x_overclock";
var.value = NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var))
{
int freq = atoi(var.value);
Settings.SuperFXClockMultiplier = freq;
}
var.key = "snes9x_up_down_allowed";
var.value = NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var))
{
Settings.UpAndDown = !strcmp(var.value, "disabled") ? false : true;
}
else
Settings.UpAndDown = false;
int disabled_channels=0;
strcpy(key, "snes9x_sndchan_x");
var.key=key;
for (int i=0;i<8;i++)
{
key[strlen("snes9x_sndchan_")]='1'+i;
var.value=NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && !strcmp("disabled", var.value))
disabled_channels|=1<<i;
}
S9xSetSoundControl(disabled_channels^0xFF);
int disabled_layers=0;
strcpy(key, "snes9x_layer_x");
for (int i=0;i<5;i++)
{
key[strlen("snes9x_layer_")]='1'+i;
var.value=NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && !strcmp("disabled", var.value))
disabled_layers|=1<<i;
}
Settings.BG_Forced=disabled_layers;
//for some reason, Transparency seems to control both the fixed color and the windowing registers?
var.key="snes9x_gfx_clip";
var.value=NULL;
Settings.DisableGraphicWindows=(environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && !strcmp("disabled", var.value));
var.key="snes9x_gfx_transp";
var.value=NULL;
Settings.Transparency=!(environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && !strcmp("disabled", var.value));
var.key="snes9x_gfx_hires";
var.value=NULL;
Settings.SupportHiRes=!(environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && !strcmp("disabled", var.value));
var.key = "snes9x_overscan";
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
{
overscan_mode newval = OVERSCAN_CROP_AUTO;
if (strcmp(var.value, "enabled") == 0)
newval = OVERSCAN_CROP_ON;
else if (strcmp(var.value, "disabled") == 0)
newval = OVERSCAN_CROP_OFF;
if (newval != crop_overscan_mode)
{
crop_overscan_mode = newval;
geometry_update = true;
}
}
var.key = "snes9x_aspect";
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
{
aspect_mode newval = ASPECT_RATIO_AUTO;
if (strcmp(var.value, "ntsc") == 0)
newval = ASPECT_RATIO_NTSC;
else if (strcmp(var.value, "pal") == 0)
newval = ASPECT_RATIO_PAL;
else if (strcmp(var.value, "4:3") == 0)
newval = ASPECT_RATIO_4_3;
else if (strcmp(var.value, "8:7") == 0)
newval = ASPECT_RATIO_8_7;
if (newval != aspect_ratio_mode)
{
aspect_ratio_mode = newval;
geometry_update = true;
}
}
if (geometry_update)
update_geometry();
}
void Surface::set_R10(double dR10)
{
_dR10=dR10;
update_geometry();
}
void Surface::set_R8(double dR8)
{
_dR8=dR8;
update_geometry();
}
void Surface::set_R6(double dR6)
{
_dR6=dR6;
update_geometry();
}
void Surface::set_R4(double dR4)
{
_dR4=dR4;
update_geometry();
}
void Surface::set_curvature(double dCurvature)
{
_dCurvature=dCurvature;
update_geometry();
}
