/**
* Inicialize the button_width and button_height values.
*
* button_width is computed as width of the whole keyboard / 10
* button_height is computed as height of the whole keyboard / 5
*
*/
void
KeyboardControl::set_buttons_size()
{
button_width = get_width() / 10;
button_height = get_height() / 5;
}
void stretch(SDL_Surface *src) {
stretch(0, 0, get_width(), get_height(),
src, 0, 0, src->w, src->h);
}
void LCD_GetCharDimensions(u32 c, u16 *width, u16 *height) {
*height = HEIGHT(cur_str.font);
*width = get_width(c);
}
/**
* \brief Returns the size of the surface containing the text.
* \return the size of the surface
*/
const Rectangle TextSurface::get_size() const {
return Rectangle(0, 0, get_width(), get_height());
}
void clear(const Color color) {
fill_rectangle(0, 0, get_width(), get_height(), color);
}
void
TexturePatch::adjust_colors(std::vector<math::Vec3f> const & adjust_values) {
assert(blending_mask != NULL);
validity_mask->fill(0);
mve::FloatImage::Ptr iadjust_values = mve::FloatImage::create(get_width(), get_height(), 3);
for (std::size_t i = 0; i < texcoords.size(); i += 3) {
math::Vec2f v1 = texcoords[i];
math::Vec2f v2 = texcoords[i + 1];
math::Vec2f v3 = texcoords[i + 2];
Tri tri(v1, v2, v3);
float area = tri.get_area();
if (area < std::numeric_limits<float>::epsilon()) continue;
Rect<float> aabb = tri.get_aabb();
int const min_x = static_cast<int>(std::floor(aabb.min_x)) - texture_patch_border;
int const min_y = static_cast<int>(std::floor(aabb.min_y)) - texture_patch_border;
int const max_x = static_cast<int>(std::ceil(aabb.max_x)) + texture_patch_border;
int const max_y = static_cast<int>(std::ceil(aabb.max_y)) + texture_patch_border;
assert(0 <= min_x && max_x <= get_width());
assert(0 <= min_y && max_y <= get_height());
for (int y = min_y; y < max_y; ++y) {
for (int x = min_x; x < max_x; ++x) {
math::Vec3f bcoords = tri.get_barycentric_coords(x, y);
bool inside = bcoords.minimum() >= 0.0f;
if (inside) {
assert(x != 0 && y != 0);
for (int c = 0; c < 3; ++c) {
iadjust_values->at(x, y, c) = math::interpolate(
adjust_values[i][c], adjust_values[i + 1][c], adjust_values[i + 2][c],
bcoords[0], bcoords[1], bcoords[2]);
}
validity_mask->at(x, y, 0) = 255;
blending_mask->at(x, y, 0) = 255;
} else {
if (validity_mask->at(x, y, 0) == 255)
continue;
/* Check whether the pixels distance from the triangle is more than one pixel. */
float ha = 2.0f * -bcoords[0] * area / (v2 - v3).norm();
float hb = 2.0f * -bcoords[1] * area / (v1 - v3).norm();
float hc = 2.0f * -bcoords[2] * area / (v1 - v2).norm();
if (ha > sqrt_2 || hb > sqrt_2 || hc > sqrt_2)
continue;
for (int c = 0; c < 3; ++c) {
iadjust_values->at(x, y, c) = math::interpolate(
adjust_values[i][c], adjust_values[i + 1][c], adjust_values[i + 2][c],
bcoords[0], bcoords[1], bcoords[2]);
}
validity_mask->at(x, y, 0) = 255;
blending_mask->at(x, y, 0) = 64;
}
}
}
}
for (int i = 0; i < image->get_pixel_amount(); ++i) {
if (validity_mask->at(i, 0) != 0){
for (int c = 0; c < 3; ++c) {
image->at(i, c) += iadjust_values->at(i, c);
}
} else {
math::Vec3f color(0.0f, 0.0f, 0.0f);
//DEBUG math::Vec3f color(1.0f, 0.0f, 1.0f);
std::copy(color.begin(), color.end(), &image->at(i, 0));
}
}
}
static char *process_args(CHARSET_INFO *cs, char *to, char *end,
const char* fmt, size_t arg_index, va_list ap)
{
ARGS_INFO args_arr[MAX_ARGS];
PRINT_INFO print_arr[MAX_PRINT_INFO];
uint idx= 0, arg_count= arg_index;
start:
/* Here we are at the beginning of positional argument, right after $ */
arg_index--;
print_arr[idx].flags= 0;
if (*fmt == '`')
{
print_arr[idx].flags|= ESCAPED_ARG;
fmt++;
}
if (*fmt == '-')
fmt++;
print_arr[idx].length= print_arr[idx].width= 0;
/* Get print length */
if (*fmt == '*')
{
fmt++;
fmt= get_length(fmt, &print_arr[idx].length, &print_arr[idx].flags);
print_arr[idx].length--;
DBUG_ASSERT(*fmt == '$' && print_arr[idx].length < MAX_ARGS);
args_arr[print_arr[idx].length].arg_type= 'd';
print_arr[idx].flags|= LENGTH_ARG;
arg_count= max(arg_count, print_arr[idx].length + 1);
fmt++;
}
else
fmt= get_length(fmt, &print_arr[idx].length, &print_arr[idx].flags);
if (*fmt == '.')
{
fmt++;
/* Get print width */
if (*fmt == '*')
{
fmt++;
fmt= get_width(fmt, &print_arr[idx].width);
print_arr[idx].width--;
DBUG_ASSERT(*fmt == '$' && print_arr[idx].width < MAX_ARGS);
args_arr[print_arr[idx].width].arg_type= 'd';
print_arr[idx].flags|= WIDTH_ARG;
arg_count= max(arg_count, print_arr[idx].width + 1);
fmt++;
}
else
fmt= get_width(fmt, &print_arr[idx].width);
}
else
print_arr[idx].width= SIZE_T_MAX;
fmt= check_longlong(fmt, &args_arr[arg_index].have_longlong);
if (*fmt == 'p')
args_arr[arg_index].have_longlong= (sizeof(void *) == sizeof(longlong));
args_arr[arg_index].arg_type= print_arr[idx].arg_type= *fmt;
print_arr[idx].arg_idx= arg_index;
print_arr[idx].begin= ++fmt;
while (*fmt && *fmt != '%')
fmt++;
if (!*fmt) /* End of format string */
{
uint i;
print_arr[idx].end= fmt;
/* Obtain parameters from the list */
for (i= 0 ; i < arg_count; i++)
{
switch (args_arr[i].arg_type) {
case 's':
case 'b':
args_arr[i].str_arg= va_arg(ap, char *);
break;
case 'f':
case 'g':
args_arr[i].double_arg= va_arg(ap, double);
break;
case 'd':
case 'i':
case 'u':
case 'x':
case 'X':
case 'o':
case 'p':
if (args_arr[i].have_longlong)
args_arr[i].longlong_arg= va_arg(ap,longlong);
else if (args_arr[i].arg_type == 'd' || args_arr[i].arg_type == 'i')
args_arr[i].longlong_arg= va_arg(ap, int);
else
args_arr[i].longlong_arg= va_arg(ap, uint);
break;
case 'c':
args_arr[i].longlong_arg= va_arg(ap, int);
break;
default:
DBUG_ASSERT(0);
}
}
int Image::get_cols() const {
return get_width() * get_channels();
}
/* check addon delimiter using current 4 as character
*/
static inline signed char aux_mid (zbar_decoder_t *dcode)
{
unsigned e = get_width(dcode, 4) + get_width(dcode, 5);
return(decode_e(e, dcode->ean.s4, 7));
}
void KheperaView::print_targetInfo(){
if (is_target_set()){
Point targetCenter = get_target_position();
View::print_targetInfo(_frame, get_height(), get_width(), targetCenter);
}
}
/**
* \brief Returns the size of this surface.
* \return the size of this surface
*/
Size Surface::get_size() const {
return { get_width(), get_height() };
}
void MapDrawingArea::setup_surfaces()
{
surface = Cairo::ImageSurface::create(Cairo::FORMAT_RGB24, get_width(), get_height());
}
/** Initializes the swapchain object. */
bool Anvil::Swapchain::init()
{
uint32_t n_swapchain_images = 0;
auto parent_surface_ptr = m_create_info_ptr->get_rendering_surface();
VkResult result = VK_ERROR_INITIALIZATION_FAILED;
Anvil::StructChainUniquePtr<VkSwapchainCreateInfoKHR> struct_chain_ptr;
std::vector<VkImage> swapchain_images;
const VkSurfaceTransformFlagBitsKHR swapchain_transformation = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
const WindowPlatform window_platform = m_create_info_ptr->get_window()->get_platform();
const bool is_offscreen_rendering_enabled = (window_platform == WINDOW_PLATFORM_DUMMY ||
window_platform == WINDOW_PLATFORM_DUMMY_WITH_PNG_SNAPSHOTS);
m_size.width = parent_surface_ptr->get_width ();
m_size.height = parent_surface_ptr->get_height();
/* not doing offscreen rendering */
if (!is_offscreen_rendering_enabled)
{
const auto& khr_swapchain_entrypoints = m_device_ptr->get_extension_khr_swapchain_entrypoints();
Anvil::StructChainer<VkSwapchainCreateInfoKHR> struct_chainer;
#ifdef _DEBUG
{
const Anvil::SGPUDevice* sgpu_device_ptr(dynamic_cast<const Anvil::SGPUDevice*>(m_device_ptr) );
const Anvil::DeviceType device_type = m_device_ptr->get_type();
uint32_t n_physical_devices = 0;
bool result_bool = false;
const char* required_surface_extension_name = nullptr;
VkSurfaceCapabilitiesKHR surface_caps;
VkCompositeAlphaFlagsKHR supported_composite_alpha_flags = static_cast<VkCompositeAlphaFlagsKHR>(0);
VkSurfaceTransformFlagsKHR supported_surface_transform_flags;
#ifdef _WIN32
#if defined(ANVIL_INCLUDE_WIN3264_WINDOW_SYSTEM_SUPPORT)
required_surface_extension_name = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
#endif
#else
#if defined(ANVIL_INCLUDE_XCB_WINDOW_SYSTEM_SUPPORT)
required_surface_extension_name = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
#endif
#endif
anvil_assert(required_surface_extension_name == nullptr ||
m_device_ptr->get_parent_instance()->is_instance_extension_supported(required_surface_extension_name) );
switch (device_type)
{
case Anvil::DEVICE_TYPE_SINGLE_GPU: n_physical_devices = 1; break;
default:
{
anvil_assert_fail();
}
}
for (uint32_t n_physical_device = 0;
n_physical_device < n_physical_devices;
++n_physical_device)
{
const Anvil::PhysicalDevice* current_physical_device_ptr = nullptr;
switch (device_type)
{
case Anvil::DEVICE_TYPE_SINGLE_GPU: current_physical_device_ptr = sgpu_device_ptr->get_physical_device(); break;
default:
{
anvil_assert_fail();
}
}
/* Ensure opaque composite alpha mode is supported */
anvil_assert(parent_surface_ptr->get_supported_composite_alpha_flags(&supported_composite_alpha_flags) );
anvil_assert(supported_composite_alpha_flags & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR);
/* Ensure we can use the swapchain image format */
anvil_assert(parent_surface_ptr->is_compatible_with_image_format(m_create_info_ptr->get_format(),
&result_bool) );
anvil_assert(result_bool);
/* Ensure the transformation we're about to request is supported by the rendering surface */
anvil_assert(parent_surface_ptr->get_supported_transformations(&supported_surface_transform_flags) );
anvil_assert(supported_surface_transform_flags & swapchain_transformation);
/* Ensure the requested number of swapchain images is reasonable*/
anvil_assert(parent_surface_ptr->get_capabilities(&surface_caps) );
anvil_assert(surface_caps.maxImageCount == 0 ||
surface_caps.maxImageCount >= m_create_info_ptr->get_n_images() );
}
}
#endif
{
VkSwapchainCreateInfoKHR create_info;
create_info.clipped = true; /* we won't be reading from the presentable images */
create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
create_info.flags = m_create_info_ptr->get_flags();
create_info.imageArrayLayers = 1;
create_info.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
create_info.imageExtent.height = parent_surface_ptr->get_height();
create_info.imageExtent.width = parent_surface_ptr->get_width ();
create_info.imageFormat = m_create_info_ptr->get_format ();
create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
create_info.imageUsage = m_create_info_ptr->get_usage_flags();
create_info.minImageCount = m_create_info_ptr->get_n_images ();
create_info.oldSwapchain = VK_NULL_HANDLE;
create_info.pNext = nullptr;
create_info.pQueueFamilyIndices = nullptr;
create_info.presentMode = m_create_info_ptr->get_present_mode();
create_info.preTransform = swapchain_transformation;
create_info.queueFamilyIndexCount = 0;
create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
create_info.surface = parent_surface_ptr->get_surface();
struct_chainer.append_struct(create_info);
}
struct_chain_ptr = struct_chainer.create_chain();
parent_surface_ptr->lock();
{
result = khr_swapchain_entrypoints.vkCreateSwapchainKHR(m_device_ptr->get_device_vk(),
struct_chain_ptr->get_root_struct(),
nullptr, /* pAllocator */
&m_swapchain);
}
parent_surface_ptr->unlock();
anvil_assert_vk_call_succeeded(result);
if (is_vk_call_successful(result) )
{
set_vk_handle(m_swapchain);
}
/* Retrieve swap-chain images */
result = khr_swapchain_entrypoints.vkGetSwapchainImagesKHR(m_device_ptr->get_device_vk(),
m_swapchain,
&n_swapchain_images,
nullptr); /* pSwapchainImages */
anvil_assert_vk_call_succeeded(result);
anvil_assert (n_swapchain_images > 0);
swapchain_images.resize(n_swapchain_images);
result = khr_swapchain_entrypoints.vkGetSwapchainImagesKHR(m_device_ptr->get_device_vk(),
m_swapchain,
&n_swapchain_images,
&swapchain_images[0]);
anvil_assert_vk_call_succeeded(result);
}
else /* offscreen rendering */
{
m_create_info_ptr->set_usage_flags(m_create_info_ptr->get_usage_flags() | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
n_swapchain_images = m_create_info_ptr->get_n_images();
}
for (uint32_t n_result_image = 0;
n_result_image < n_swapchain_images;
++n_result_image)
{
/* Spawn an Image wrapper class for the swap-chain image. */
if (!is_offscreen_rendering_enabled)
{
auto create_info_ptr = Anvil::ImageCreateInfo::create_swapchain_wrapper(m_device_ptr,
this,
swapchain_images[n_result_image],
n_result_image);
create_info_ptr->set_mt_safety(Anvil::Utils::convert_boolean_to_mt_safety_enum(is_mt_safe() ) );
m_image_ptrs[n_result_image] = Anvil::Image::create(std::move(create_info_ptr) );
}
else
{
auto create_info_ptr = Anvil::ImageCreateInfo::create_nonsparse_alloc(m_device_ptr,
VK_IMAGE_TYPE_2D,
m_create_info_ptr->get_format(),
VK_IMAGE_TILING_OPTIMAL,
m_create_info_ptr->get_usage_flags(),
m_size.width,
m_size.height,
1, /* base_mipmap_depth */
1,
VK_SAMPLE_COUNT_1_BIT,
QUEUE_FAMILY_GRAPHICS_BIT,
VK_SHARING_MODE_EXCLUSIVE,
false, /* in_use_full_mipmap_chain */
0, /* in_memory_features */
0, /* in_create_flags */
VK_IMAGE_LAYOUT_GENERAL,
nullptr);
create_info_ptr->set_mt_safety(Anvil::Utils::convert_boolean_to_mt_safety_enum(is_mt_safe() ) );
m_image_ptrs[n_result_image] = Anvil::Image::create(std::move(create_info_ptr) );
}
/* For each swap-chain image, create a relevant view */
{
auto create_info_ptr = Anvil::ImageViewCreateInfo::create_2D(m_device_ptr,
m_image_ptrs[n_result_image].get(),
0, /* n_base_layer */
0, /* n_base_mipmap_level */
1, /* n_mipmaps */
VK_IMAGE_ASPECT_COLOR_BIT,
m_create_info_ptr->get_format(),
VK_COMPONENT_SWIZZLE_R,
VK_COMPONENT_SWIZZLE_G,
VK_COMPONENT_SWIZZLE_B,
VK_COMPONENT_SWIZZLE_A);
create_info_ptr->set_mt_safety(Anvil::Utils::convert_boolean_to_mt_safety_enum(is_mt_safe() ) );
m_image_view_ptrs[n_result_image] = Anvil::ImageView::create(std::move(create_info_ptr) );
}
result = VK_SUCCESS;
}
/* Sign up for present submission notifications. This is needed to ensure that number of presented frames ==
* number of acquired frames at destruction time.
*/
{
std::vector<Anvil::Queue*> queues;
switch (m_device_ptr->get_type() )
{
case Anvil::DEVICE_TYPE_SINGLE_GPU:
{
const std::vector<uint32_t>* queue_fams_with_present_support_ptr(nullptr);
const auto rendering_surface_ptr (m_create_info_ptr->get_rendering_surface() );
const Anvil::SGPUDevice* sgpu_device_ptr (dynamic_cast<const Anvil::SGPUDevice*>(m_device_ptr) );
if (!rendering_surface_ptr->get_queue_families_with_present_support(&queue_fams_with_present_support_ptr) )
{
break;
}
if (queue_fams_with_present_support_ptr == nullptr)
{
anvil_assert(queue_fams_with_present_support_ptr != nullptr);
}
else
{
for (const auto queue_fam : *queue_fams_with_present_support_ptr)
{
const uint32_t n_queues = sgpu_device_ptr->get_n_queues(queue_fam);
for (uint32_t n_queue = 0;
n_queue < n_queues;
++n_queue)
{
auto queue_ptr = sgpu_device_ptr->get_queue_for_queue_family_index(queue_fam,
n_queue);
anvil_assert(queue_ptr != nullptr);
if (std::find(queues.begin(),
queues.end(),
queue_ptr) == queues.end() )
{
queues.push_back(queue_ptr);
}
}
}
}
break;
}
}
for (auto queue_ptr : queues)
{
queue_ptr->register_for_callbacks(
QUEUE_CALLBACK_ID_PRESENT_REQUEST_ISSUED,
std::bind(&Swapchain::on_present_request_issued,
this,
std::placeholders::_1),
this
);
m_observed_queues.push_back(queue_ptr);
}
}
/* Sign up for "about to close the parent window" notifications. Swapchain instance SHOULD be deinitialized
* before the window is destroyed, so we're going to act as nice citizens.
*/
m_create_info_ptr->get_window()->register_for_callbacks(
WINDOW_CALLBACK_ID_ABOUT_TO_CLOSE,
std::bind(&Swapchain::on_parent_window_about_to_close,
this),
this
);
return is_vk_call_successful(result);
}
bool
KeyboardControl::is_landscape() {
return get_width() >= get_height();
}
/**
* Returns whether the ScrollBar is defined or has to be set up first
* @return True if the ScrollBar is defined,
* False if it has to be set up first
*/
bool defined() const {
return get_width() > 0;
}
/** Inherited from tscrollbar. */
unsigned get_length() const { return get_width(); }
bool test_new_piece()
{
bool result = true;
for (int x = 0; x < 5; x++) {
for (int y = 0; y < 5; y++) {
for (int compt_small = 0; compt_small < 2; ++compt_small) {
for (int compt_horizontal = 0; compt_horizontal < 2; ++compt_horizontal) {
int size;
bool small;
bool horizontal;
if (compt_small == 0) {
small = true;
size = 2;
} else {
small = false;
size = 3;
}
if (compt_horizontal == 0)
horizontal = true;
else
horizontal = false;
piece p = new_piece_rh(x, y, small, horizontal);
result = result && test_equality_int(x, get_x(p), "get_x");
result = result && test_equality_int(y, get_y(p), "get_y");
if (horizontal) {
result = result && test_equality_int(1, get_height(p), "get_height");
result = result && test_equality_int(size, get_width(p), "get_width");
result = result && test_equality_bool(true, can_move_x(p), "can_move_x");
result = result && test_equality_bool(false, can_move_y(p), "can_move_y");
} else {
result = result && test_equality_int(size, get_height(p), "get_height");
result = result && test_equality_int(1, get_width(p), "get_width");
result = result && test_equality_bool(false, can_move_x(p), "can_move_x");
result = result && test_equality_bool(true, can_move_y(p), "can_move_y");
}
delete_piece(p);
}
}
for (int width = 1; width < 4; width++) {
for (int height = 1; height < 4; height++) {
for (int compt_move_x = 0; compt_move_x < 2; ++compt_move_x) {
for (int compt_move_y = 0; compt_move_y < 2; ++compt_move_y) {
bool move_x;
bool move_y;
if (compt_move_x == 0)
move_x = true;
else
move_x = false;
if (compt_move_y == 0)
move_y = true;
else
move_y = false;
piece p = new_piece(x, y, width, height, move_x, move_y);
result = result && test_equality_int(x, get_x(p), "get_x");
result = result && test_equality_int(y, get_y(p), "get_y");
result = result && test_equality_int(height, get_height(p), "get_height");
result = result && test_equality_int(width, get_width(p), "get_width");
if (move_x)
result = result && test_equality_bool(true, can_move_x(p), "can_move_x");
else
result = result && test_equality_bool(false, can_move_x(p), "not can_move_x");
if (move_y)
result = result && test_equality_bool(true, can_move_y(p), "can_move_y");
else
result = result && test_equality_bool(false, can_move_y(p), "not can_move_y");
delete_piece(p);
}
}
}
}
}
}
return result;
}
/**
* Callback when canvas recieves an expose event. The icon is entirely
* redrawn for every expose event instead of checking and redrawing
* just the dirty regions. Since the icon is so small, the gain
* probably isn't worth the extra overhead.
*/
gboolean
on_canvas_expose_event(GtkWidget *widget, GdkEventExpose *event,
gpointer unused_udata)
{
GdkRectangle panel, rect, bar;
(void) unused_udata;
/* just draw once for all expose events */
if (event->count)
return FALSE;
/* setup image column */
panel.x = ICON_INSET;
panel.y = ICON_INSET;
panel.height = (widget->allocation.height - ICON_INSET2) / 3;
panel.width = XPM_WIDTH;
/* draw connection icon */
center_image(&rect, &panel, con_pixbuf);
gdk_draw_pixbuf(canvas->window, NULL, con_pixbuf, 0, 0,
rect.x, rect.y, rect.width, rect.height, GDK_RGB_DITHER_NONE, 0, 0);
panel.y += panel.height;
/* paint download icon */
center_image(&rect, &panel, down_pixbuf);
gdk_draw_pixbuf(canvas->window, NULL, down_pixbuf, 0, 0,
rect.x, rect.y, rect.width, rect.height, GDK_RGB_DITHER_NONE, 0, 0);
panel.y += panel.height;
/* paint upload icon */
center_image(&rect, &panel, up_pixbuf);
gdk_draw_pixbuf(canvas->window, NULL, up_pixbuf, 0, 0,
rect.x, rect.y, rect.width, rect.height, GDK_RGB_DITHER_NONE, 0, 0);
/* setup bar column */
panel.x = XPM_WIDTH + ICON_INSET;
panel.y = ICON_INSET;
panel.width = (ICON_WIDTH - ICON_INSET2) - XPM_WIDTH;
panel.height = (widget->allocation.height - ICON_INSET2);
/* draw bar panel */
gtk_paint_box(widget->style, widget->window,
GTK_STATE_INSENSITIVE, GTK_SHADOW_OUT,
NULL, widget, NULL,
panel.x, panel.y, panel.width, panel.height);
panel.height /= 3;
rect.x = panel.x + ICON_INSET2;
rect.y = panel.y + ICON_INSET2;
rect.width = panel.width - ICON_INSET4;
rect.height = panel.height - ICON_INSET4;
bar.x = rect.x + ICON_INSET;
bar.y = rect.y + ICON_INSET;
bar.width = rect.width - ICON_INSET2;
bar.height = rect.height - ICON_INSET2;
/* paint connection bar */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, NULL,
rect.x, rect.y, rect.width, rect.height);
gdk_draw_rectangle(widget->window, widget->style->black_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
bar.width = get_width(&bar, leaf_cnt + norm_cnt + ultra_cnt, con_max);
gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
panel.y += panel.height;
rect.y += panel.height;
bar.y += panel.height;
bar.width = rect.width - ICON_INSET2;
/* paint download bar */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, NULL,
rect.x, rect.y, rect.width, rect.height);
gdk_draw_rectangle(widget->window, widget->style->black_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
bar.width = get_width(&bar, down_cnt, down_max);
gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
panel.y += panel.height;
rect.y += panel.height;
bar.y += panel.height;
bar.width = rect.width - ICON_INSET2;
/* paint upload bar */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, NULL,
rect.x, rect.y, rect.width, rect.height);
gdk_draw_rectangle(widget->window, widget->style->black_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
bar.width = get_width(&bar, up_cnt, up_max);
gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
/* paint border */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, NULL, 0, 0, -1, -1);
return FALSE;
}
std::shared_ptr<pipeline_profile> pipeline_config::resolve(std::shared_ptr<pipeline> pipe)
{
std::lock_guard<std::mutex> lock(_mtx);
_resolved_profile.reset();
auto requested_device = resolve_device_requests(pipe);
std::vector<stream_profile> resolved_profiles;
//if the user requested all streams, or if the requested device is from file and the user did not request any stream
if (_enable_all_streams || (!_device_request.filename.empty() && _stream_requests.empty()))
{
if (!requested_device)
{
requested_device = get_first_or_default_device(pipe);
}
util::config config;
config.enable_all(util::best_quality);
_resolved_profile = std::make_shared<pipeline_profile>(requested_device, config, _device_request.record_output);
return _resolved_profile;
}
else
{
util::config config;
//If the user did not request anything, give it the default
if (_stream_requests.empty())
{
if (!requested_device)
{
requested_device = get_first_or_default_device(pipe);
}
auto default_profiles = get_default_configuration(requested_device);
for (auto prof : default_profiles)
{
auto p = dynamic_cast<video_stream_profile*>(prof.get());
if (!p)
{
LOG_ERROR("prof is not video_stream_profile");
throw std::logic_error("Failed to resolve request. internal error");
}
config.enable_stream(p->get_stream_type(), p->get_stream_index(), p->get_width(), p->get_height(), p->get_format(), p->get_framerate());
}
_resolved_profile = std::make_shared<pipeline_profile>(requested_device, config, _device_request.record_output);
return _resolved_profile;
}
else
{
//User enabled some stream, enable only them
for(auto&& req : _stream_requests)
{
auto r = req.second;
config.enable_stream(r.stream, r.stream_index, r.width, r.height, r.format, r.fps);
}
auto devs = pipe->get_context()->query_devices();
if (devs.empty())
{
auto dev = get_first_or_default_device(pipe);
_resolved_profile = std::make_shared<pipeline_profile>(dev, config, _device_request.record_output);
return _resolved_profile;
}
else
{
for (auto dev_info : devs)
{
try
{
auto dev = dev_info->create_device();
_resolved_profile = std::make_shared<pipeline_profile>(dev, config, _device_request.record_output);
return _resolved_profile;
}
catch (...) {}
}
}
throw std::runtime_error("Failed to resolve request. No device found that satisfies all requirements");
}
}
assert(0); //Unreachable code
}
void
EditorInputCenter::fill() {
auto tilemap = dynamic_cast<TileMap*>(Editor::current()->layerselect.selected_tilemap);
if (! tilemap) {
return;
}
// The tile that is going to be replaced:
Uint32 replace_tile = tilemap->get_tile_id(hovered_tile.x, hovered_tile.y);
if (Editor::current()->tileselect.tiles->pos(0, 0) == tilemap->get_tile_id(hovered_tile.x, hovered_tile.y)) {
// Replacing by the same tiles shouldn't do anything.
return;
}
std::vector<Vector> pos_stack;
pos_stack.clear();
pos_stack.push_back(hovered_tile);
auto tiles = Editor::current()->tileselect.tiles.get();
// Passing recursively trough all tiles to be replaced...
while (pos_stack.size()) {
if (pos_stack.size() > 1000000) {
log_warning << "More than 1'000'000 tiles in stack to fill, STOP" << std::endl;
return;
}
Vector pos = pos_stack[pos_stack.size() - 1];
Vector tpos = pos - hovered_tile;
// Tests for being inside tilemap:
if ( pos.x < 0 || pos.y < 0 ||
pos.x >= tilemap->get_width() || pos.y >= tilemap->get_height()) {
pos_stack.pop_back();
continue;
}
input_tile(pos, tiles->pos(tpos.x, tpos.y));
Vector pos_;
// Going left...
pos_ = pos + Vector(-1, 0);
if (pos_.x >= 0) {
if (replace_tile == tilemap->get_tile_id(pos_.x, pos_.y) &&
replace_tile != tiles->pos(tpos.x - 1, tpos.y)) {
pos_stack.push_back( pos_ );
continue;
}
}
// Going right...
pos_ = pos + Vector(1, 0);
if (pos_.x < tilemap->get_width()) {
if (replace_tile == tilemap->get_tile_id(pos_.x, pos_.y) &&
replace_tile != tiles->pos(tpos.x + 1, tpos.y)) {
pos_stack.push_back( pos_ );
continue;
}
}
// Going up...
pos_ = pos + Vector(0, -1);
if (pos_.y >= 0) {
if (replace_tile == tilemap->get_tile_id(pos_.x, pos_.y) &&
replace_tile != tiles->pos(tpos.x, tpos.y - 1)) {
pos_stack.push_back( pos_ );
continue;
}
}
// Going down...
pos_ = pos + Vector(0, 1);
if (pos_.y < tilemap->get_height()) {
if (replace_tile == tilemap->get_tile_id(pos_.x, pos_.y) &&
replace_tile != tiles->pos(tpos.x, tpos.y + 1)) {
pos_stack.push_back( pos_ );
continue;
}
}
// When tiles on each side are already filled or occupied by another tiles, it ends.
pos_stack.pop_back();
}
}
int main(int argc, char* argv[])
{
stringtab_init();
pass_opt_t opt;
pass_opt_init(&opt);
opt.release = true;
opt.output = ".";
ast_setwidth(get_width());
bool print_program_ast = false;
bool print_package_ast = false;
opt_state_t s;
opt_init(args, &s, &argc, argv);
bool ok = true;
bool print_usage = false;
int id;
while((id = opt_next(&s)) != -1)
{
switch(id)
{
case OPT_VERSION:
printf("%s\n", PONY_VERSION);
return 0;
case OPT_DEBUG: opt.release = false; break;
case OPT_BUILDFLAG: define_build_flag(s.arg_val); break;
case OPT_STRIP: opt.strip_debug = true; break;
case OPT_PATHS: package_add_paths(s.arg_val); break;
case OPT_OUTPUT: opt.output = s.arg_val; break;
case OPT_LIBRARY: opt.library = true; break;
case OPT_DOCS: opt.docs = true; break;
case OPT_SAFE:
if(!package_add_safe(s.arg_val))
ok = false;
break;
case OPT_IEEEMATH: opt.ieee_math = true; break;
case OPT_CPU: opt.cpu = s.arg_val; break;
case OPT_FEATURES: opt.features = s.arg_val; break;
case OPT_TRIPLE: opt.triple = s.arg_val; break;
case OPT_STATS: opt.print_stats = true; break;
case OPT_AST: print_program_ast = true; break;
case OPT_ASTPACKAGE: print_package_ast = true; break;
case OPT_TRACE: parse_trace(true); break;
case OPT_WIDTH: ast_setwidth(atoi(s.arg_val)); break;
case OPT_IMMERR: error_set_immediate(true); break;
case OPT_VERIFY: opt.verify = true; break;
case OPT_FILENAMES: opt.print_filenames = true; break;
case OPT_CHECKTREE: enable_check_tree(true); break;
case OPT_BNF: print_grammar(false, true); return 0;
case OPT_ANTLR: print_grammar(true, true); return 0;
case OPT_ANTLRRAW: print_grammar(true, false); return 0;
case OPT_PASSES:
if(!limit_passes(&opt, s.arg_val))
{
ok = false;
print_usage = true;
}
break;
default: usage(); return -1;
}
}
for(int i = 1; i < argc; i++)
{
if(argv[i][0] == '-')
{
printf("Unrecognised option: %s\n", argv[i]);
ok = false;
print_usage = true;
}
}
#ifdef PLATFORM_IS_WINDOWS
opt.strip_debug = true;
#endif
if(!ok)
{
print_errors();
if(print_usage)
usage();
return -1;
}
if(package_init(&opt))
{
if(argc == 1)
{
ok &= compile_package(".", &opt, print_program_ast, print_package_ast);
} else {
for(int i = 1; i < argc; i++)
ok &= compile_package(argv[i], &opt, print_program_ast,
print_package_ast);
}
}
if(!ok && get_error_count() == 0)
printf("Error: internal failure not reported\n");
package_done(&opt);
pass_opt_done(&opt);
stringtab_done();
return ok ? 0 : -1;
}
/**
* \brief Tests whether a rectangle has overlaps the outside part of the map area.
* \param collision_box the rectangle to check
* \return true if a point of the rectangle is outside the map area
*/
bool Map::test_collision_with_border(const Rectangle& collision_box) const {
return collision_box.get_x() < 0 || collision_box.get_x() + collision_box.get_width() >= get_width()
|| collision_box.get_y() < 0 || collision_box.get_y() + collision_box.get_height() >= get_height();
}
void clear() {
rectangle(0, 0, get_width(), get_height());
}
/**
* Returns whether the given y-Coordinate is on the up arrow
* @param y y-Coordinate to check
* @return True if the given y-Coordinate is on the up arrow,
* False otherwise
*/
bool in_up_arrow(PixelScalar y) const {
return y < rc.top + get_width();
}
void clear(const Brush &brush) {
fill_rectangle(0, 0, get_width(), get_height(), brush);
}
/**
* Returns whether the given y-Coordinate is on the down arrow
* @param y y-Coordinate to check
* @return True if the given y-Coordinate is on the down arrow,
* False otherwise
*/
bool in_down_arrow(PixelScalar y) const {
return y >= rc.bottom - get_width();
}
void copy_and(const Bitmap &src) {
copy_and(0, 0, get_width(), get_height(), src, 0, 0);
}
/** Returns the height of the scrollable area of the ScrollBar */
PixelScalar get_netto_height() const {
return get_height() - 2 * get_width() - 1;
}
int main(){
char s[1024];
v.clear(); ans.clear();
col = 0; row = 0; count = 0;
while(true){
while(gets(s)){
if(s[0] == '%'){//finish
break;
} else {
int nowi = 0;
while(s[nowi] != '\0'){
if(s[nowi] != ' ')
v.push_back(s[nowi]);
nowi++;
}
row++;
}
}
col = v.size() / row;
//printf("col = %d row = %d count = %d\n", col, row, count);
ans.resize(row);
for(int i = 0; i < row; i++)
ans[i].resize(col);
for(int i = 0; i < row; i++)
for(int j = 0; j < col; j++)
ans[i][j] = 0;
//calculate
count = 1;
for(int i = 0; i < row; i++)
for(int j = 0; j < col; j++)
if(ans[i][j] == 0){
//printf("v(%d, %d) = %c\n", i, j, v[i*col+j]);
fill_count(i, j, &count, &v[i*col+j]);
count++;
}
//print
int* max_width = (int*)malloc(sizeof(int)*col);
int maxnumincol;
for(int j = 0; j < col; j++){
maxnumincol = 0;
for(int i = 0; i < row; i++)
if(ans[i][j] > maxnumincol)
maxnumincol = ans[i][j];
max_width[j] = get_width(maxnumincol) + 1;
}
max_width[0]--;//no need ' '
for(int i = 0; i < row; i++){
for(int j = 0; j < col; j++)
printf("%*d", max_width[j], ans[i][j]);
puts("");
}
puts("%");
free(max_width);
//clear
v.clear();
col = 0;row = 0;count = 0;
if(s[0] != '%')// so op!!
break;
}
return 0;
}
int main() {
int message_space, x = 0, y = 0;
key k;
char *message;
start_charm();
message_space = 3;
clear_screen();
move_cursor(x, y);
blot_char('@');
k = get_key();
while (k != KEY_ESCAPE && k != KEY_Q) {
switch (k) {
case KEY_UP:
if (y > 0) {
y--;
}
break;
case KEY_DOWN:
if (y < get_height() - message_space - 1) {
y++;
}
break;
case KEY_RIGHT:
if (x < get_width() - 1) {
x++;
}
break;
case KEY_LEFT:
if (x > 0) {
x--;
}
break;
default:
;
}
clear_screen();
message = (char *) malloc(20 * sizeof(char));
if (message != NULL) {
(void) snprintf(message, 20, "Cursor: (%d, %d)", get_x(), get_y());
move_cursor(0, get_height());
hcenter_string(message);
free(message);
move_cursor(x, y);
blot_char('@');
}
k = get_key();
}
end_charm();
return 0;
}
