CL_GUIComponent_Impl *CL_GUIComponent_Impl::create_from_manager(CL_GUIManager *manager)
{
if (manager)
return new CL_GUIComponent_Impl(manager->impl, 0, true);
else
throw CL_Exception("Cannot create component with a null manager!");
}
CL_Resource CL_ResourceManager::get_resource(
const CL_String &resource_id,
bool resolve_alias,
int reserved)
{
std::map<CL_String, CL_Resource>::const_iterator it;
it = impl->resources.find(resource_id);
if (it != impl->resources.end())
return it->second;
std::vector<CL_ResourceManager>::size_type i;
for (i = 0; i < impl->additional_resources.size(); i++)
{
try
{
return impl->additional_resources[i].get_resource(
resource_id, resolve_alias, reserved);
}
catch (const CL_Exception&)
{
}
}
throw CL_Exception(cl_format("Resource not found: %1", resource_id));
return CL_Resource(impl->document.get_document_element(), *this);
}
CL_GUIComponent_Impl *CL_GUIComponent_Impl::create_from_parent(CL_GUIComponent *parent)
{
if (parent)
return new CL_GUIComponent_Impl(parent->get_gui_manager().impl, parent, false);
else
throw CL_Exception("Cannot create child component with no parent!");
}
void CL_Collada_Triangles_Impl::create_vertices(CL_Vec2f *destination, int stride, const CL_String &semantic)
{
CL_Collada_Input_Shared &input = get_input(semantic);
CL_Collada_Source &source = input.get_source();
if (source.is_null())
{
throw CL_Exception("unsupported situation. fixme");
}
std::vector<CL_Vec2f> &pos_array = source.get_vec2f_array();
if (!stride)
stride = sizeof(CL_Vec2f);
char *work_ptr = (char *) destination;
int primitive_stride = this->stride;
unsigned int offset = input.get_offset();
unsigned int max = offset + (triangle_count * 3 * primitive_stride);
for (unsigned int cnt=offset; cnt < max; cnt+=primitive_stride)
{
*( (CL_Vec2f *) work_ptr ) = pos_array[ primitive[cnt] ];
work_ptr += stride;
}
}
CL_ListViewColumnHeader CL_ListViewHeader::remove(const CL_StringRef &column_id)
{
CL_SharedPtr<CL_ListViewColumnHeader_Impl> cur = impl->first_column;
while (cur)
{
if (cur->column_id == column_id)
{
CL_ListViewColumnHeader column(cur);
if (!impl->func_column_removed.is_null())
impl->func_column_removed.invoke(column);
if (!cur->prev_sibling.expired())
cur->prev_sibling.lock()->next_sibling = cur->next_sibling;
if (cur->next_sibling)
cur->next_sibling->prev_sibling = cur->prev_sibling;
if (impl->first_column == cur)
impl->first_column = cur->next_sibling;
if (impl->last_column.lock() == cur)
impl->last_column = cur->prev_sibling;
return column;
}
cur = cur->next_sibling;
}
throw CL_Exception(cl_format("No column found with column id: %1", column_id));
}
bool CL_IODeviceProvider_File::seek(int position, CL_IODevice::SeekMode seek_mode)
{
if (handle == invalid_handle)
throw CL_Exception("CL_IODeviceProvider_File::seek(): Unable to get file position pointer, no file open");
#ifdef WIN32
DWORD moveMethod = FILE_BEGIN;
switch (seek_mode)
{
case CL_IODevice::seek_set: moveMethod = FILE_BEGIN; break;
case CL_IODevice::seek_cur: moveMethod = FILE_CURRENT; break;
case CL_IODevice::seek_end: moveMethod = FILE_END; break;
}
DWORD new_pos = SetFilePointer(handle, position, 0, moveMethod);
return (new_pos != INVALID_FILE_SIZE);
#else
int mode = SEEK_SET;
if (seek_mode == CL_File::seek_set)
mode = SEEK_SET;
else if (seek_mode == CL_File::seek_cur)
mode = SEEK_CUR;
else if (seek_mode == CL_File::seek_end)
mode = SEEK_END;
off_t new_pos = lseek(handle, position, mode);
if (new_pos == (off_t) -1)
return false;
else
return true;
#endif
}
CL_VirtualDirectoryListing CL_VirtualFileSystem::get_directory_listing(const CL_String &path_rel)
{
CL_String path = CL_PathHelp::make_absolute(
"/",
path_rel,
CL_PathHelp::path_type_virtual);
// First see if its a mount point:
int index, size;
size = (int) impl->mounts.size();
for (index = 0; index < size; index++)
{
if (impl->mounts[index].first == path.substr(0, impl->mounts[index].first.length()))
{
return impl->mounts[index].second.get_directory_listing( path.substr(impl->mounts[index].first.length(), path.length()));
}
}
// Try open locally, if we got a file provider attached
if (impl->provider)
{
return CL_VirtualDirectoryListing(
impl->provider,
CL_PathHelp::make_relative(
"/",
path,
CL_PathHelp::path_type_virtual));
}
else
throw CL_Exception(cl_format("Unable to list directory: %1", path));
}
CL_ConsoleWindow_Generic::CL_ConsoleWindow_Generic(
const CL_StringRef &title,
int width,
int height)
{
#ifdef WIN32
AllocConsole();
SetConsoleTitle(CL_StringHelp::utf8_to_ucs2(title).c_str());
COORD coord;
coord.X = width;
coord.Y = height;
scrbuf =
CreateConsoleScreenBuffer(
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
CONSOLE_TEXTMODE_BUFFER,
NULL);
if(scrbuf == INVALID_HANDLE_VALUE)
throw CL_Exception("Unable to allocate console screen buffer");
SetStdHandle(STD_OUTPUT_HANDLE, scrbuf);
SetConsoleActiveScreenBuffer(scrbuf);
SetConsoleScreenBufferSize(scrbuf, coord);
#endif
}
void CL_Lib3dsFile::load(CL_IODevice device)
{
CL_Lib3dsIo io(device);
int result = lib3ds_file_read(file, io);
if (!result)
throw CL_Exception("Unable to load 3ds file");
}
void CL_Lib3dsFile::save(CL_IODevice device)
{
CL_Lib3dsIo io(device);
int result = lib3ds_file_write(file, io);
if (!result)
throw CL_Exception("Unable to save 3ds file");
}
CL_GUIComponent_Impl *CL_GUIComponent_Impl::create_from_owner(CL_GUIComponent *owner)
{
if (owner)
return new CL_GUIComponent_Impl(owner->get_gui_manager().impl, owner, true);
else
throw CL_Exception("Cannot create child component with a null owner!");
}
CL_DomNode CL_DomNode::select_node(const CL_DomString &xpath_expression) const
{
std::vector<CL_DomNode> nodes = select_nodes(xpath_expression);
if (nodes.empty())
throw CL_Exception(cl_format("Xpath did not match any node: %1", xpath_expression));
return nodes[0];
}
CL_Service_Impl::CL_Service_Impl(CL_Service *service, const CL_String &service_name)
: service_name(service_name), service(service)
{
if (instance != 0)
throw CL_Exception("More than one instance of CL_Service not allowed");
instance = this;
}
void CL_NetGameClient_Impl::process()
{
CL_MutexSection mutex_lock(&mutex);
event_arrived.reset();
std::vector<CL_NetGameNetworkEvent> new_events;
new_events.swap(events);
mutex_lock.unlock();
for (unsigned int i = 0; i < new_events.size(); i++)
{
switch (new_events[i].type)
{
case CL_NetGameNetworkEvent::client_connected:
sig_game_connected.invoke();
break;
case CL_NetGameNetworkEvent::event_received:
sig_game_event_received.invoke(new_events[i].game_event);
break;
case CL_NetGameNetworkEvent::client_disconnected:
sig_game_disconnected.invoke();
connection.reset();
break;
default:
throw CL_Exception("Unknown server event type");
}
}
}
void CL_RegistryKey::set_value_int(const CL_StringRef &name, int value)
{
DWORD v = value;
LONG result = RegSetValueEx(impl->key, name.empty() ? 0 : CL_StringHelp::utf8_to_ucs2(name).c_str(), 0, REG_DWORD, (const BYTE *) &v, sizeof(DWORD));
if (result != ERROR_SUCCESS)
throw CL_Exception(cl_format("Unable to set registry key value %1", name));
}
int App::start(const std::vector<CL_String> &args)
{
CL_String theme;
if (CL_FileHelp::file_exists("../../../Resources/GUIThemeAero/theme.css"))
theme = "../../../Resources/GUIThemeAero";
else if (CL_FileHelp::file_exists("../../../Resources/GUIThemeBasic/theme.css"))
theme = "../../../Resources/GUIThemeBasic";
else
throw CL_Exception("Not themes found");
CL_GUIManager gui(theme);
CL_DisplayWindowDescription win_desc;
win_desc.set_allow_resize(true);
win_desc.set_title("GUILayout Test Application");
win_desc.set_position(CL_Rect(200, 200, 540, 440), false);
win_desc.set_visible(false);
CL_Window window(&gui, win_desc);
window.func_close().set(this, &App::on_close, &window);
CL_GUILayoutCorners layout;
window.set_layout(layout);
window.create_components("Resources/layout.xml");
CL_PushButton *button = CL_PushButton::get_named_item(&window, "MyButton");
button->func_clicked().set(this, &App::on_button_clicked, button);
label = CL_Label::get_named_item(&window, "MyLabel");
window.set_visible(true);
gui.exec();
return 0;
}
CL_RegistryKey CL_RegistryKey::create_key(const CL_StringRef &subkey, unsigned int access_rights, CreateFlags create_flags)
{
DWORD disposition = 0;
HKEY new_key = 0;
LONG result = RegCreateKeyEx(impl->key, CL_StringHelp::utf8_to_ucs2(subkey).c_str(), 0, 0, (create_flags & create_volatile) ? REG_OPTION_VOLATILE : REG_OPTION_NON_VOLATILE, access_rights, 0, &new_key, &disposition);
if (result != ERROR_SUCCESS)
throw CL_Exception(cl_format("Unable to create registry key %1", subkey));
if (disposition != REG_CREATED_NEW_KEY && (create_flags & create_new))
{
RegCloseKey(new_key);
throw CL_Exception(cl_format("Key already exists: %1", subkey));
}
return CL_RegistryKey(new_key);
}
void CL_RegistryKey::delete_key(PredefinedKey key, const CL_StringRef &subkey, bool recursive)
{
HKEY hkey = CL_RegistryKey_Impl::get_predefined_hkey(key);
if (recursive)
{
DWORD result = SHDeleteKey(hkey, CL_StringHelp::utf8_to_ucs2(subkey).c_str());
if (result != ERROR_SUCCESS)
throw CL_Exception(cl_format("Unable to delete registry key %1", subkey));
}
else
{
LONG result = RegDeleteKey(hkey, CL_StringHelp::utf8_to_ucs2(subkey).c_str());
if (result != ERROR_SUCCESS)
throw CL_Exception(cl_format("Unable to delete registry key %1", subkey));
}
}
CL_CSSBoxLength CL_CSSResourceCache::compute_length(const CL_CSSBoxLength &length, float em_size, float ex_size)
{
float dpi = 96.0f;
float px_size = 1.0f;
/*
if (is_printer)
{
if (printer.dpi == 300)
{
dpi = 300.0f;
px_size = 3.0f;
}
else if (printer.dpi == 600)
{
dpi = 600.0f;
px_size = 5.0f;
}
else
{
dpi = printer.dpi;
px_size = (float)(int)(0.20f * dpi / 25.4f + 0.5f); // Find the closest pixel size matching 0.20mm
}
}
*/
CL_CSSBoxLength new_length;
new_length.type = CL_CSSBoxLength::type_computed_px;
switch (length.type)
{
case CL_CSSBoxLength::type_computed_px:
new_length.value = length.value;
break;
case CL_CSSBoxLength::type_mm:
new_length.value = length.value * dpi / 25.4f;
break;
case CL_CSSBoxLength::type_cm:
new_length.value = length.value * dpi / 2.54f;
break;
case CL_CSSBoxLength::type_in:
new_length.value = length.value * dpi;
break;
case CL_CSSBoxLength::type_pt:
new_length.value = length.value * dpi / 72.0f;
break;
case CL_CSSBoxLength::type_pc:
new_length.value = length.value * dpi * 12.0f / 72.0f;
break;
case CL_CSSBoxLength::type_em:
new_length.value = length.value * em_size;
break;
case CL_CSSBoxLength::type_ex:
new_length.value = length.value * ex_size;
break;
case CL_CSSBoxLength::type_px:
new_length.value = length.value * px_size;
break;
default:
throw CL_Exception("Unknown css length dimension!");
}
return new_length;
}
void Model_Impl::Draw(CL_GraphicContext &gc, GraphicStore *gs, const CL_Mat4f &modelview_matrix)
{
gc.set_modelview(modelview_matrix);
CL_PrimitivesArray prim_array(gc);
prim_array.set_attributes(0, vbo_positions, 3, cl_type_float, (void *) 0);
prim_array.set_attributes(1, vbo_normals, 3, cl_type_float, (void *) 0);
if (!vbo_texcoords.is_null())
{
prim_array.set_attributes(2, vbo_texcoords, 2, cl_type_float, (void *) 0);
gc.set_texture(0, gs->texture_underwater);
gc.set_texture(1, gs->texture_background);
gs->shader_texture.SetMaterial(material_shininess, material_emission, material_ambient, material_specular);
gs->shader_texture.Use(gc);
}
else
{
throw CL_Exception("What! no texure coordinates?");
}
gc.draw_primitives(cl_triangles, vbo_size, prim_array);
gc.reset_texture(0);
gc.reset_texture(0);
}
int Model_Impl::count_vertices(const struct aiScene* sc, const struct aiNode* nd)
{
int vertex_count = 0;
unsigned int n = 0, t;
// All meshes assigned to this node
for (; n < nd->mNumMeshes; ++n)
{
const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]];
int num_vertex = mesh->mNumFaces * 3;
if (!num_vertex)
continue;
vertex_count += num_vertex;
for (t = 0; t < mesh->mNumFaces; ++t)
{
if (mesh->mFaces[t].mNumIndices != 3)
throw CL_Exception("This example only supports triangles");
}
}
// All children
for (n = 0; n < nd->mNumChildren; ++n)
{
vertex_count += count_vertices(sc, nd->mChildren[n]);
}
return vertex_count;
}
int CL_PgsqlReaderProvider::get_name_index(const CL_StringRef &name) const
{
int index = PQfnumber(result, name.c_str());
if (index < 0)
throw CL_Exception(cl_format("No such column name %1", name));
return index;
}
void LoginEvents::on_event_login_failed(const CL_NetGameEvent &e)
{
CL_String fail_reason = e.get_argument(0);
// TODO: Handle failed login more gracefully
throw CL_Exception("Login failed: " + fail_reason);
}
TileMap::TileMap(CL_GraphicContext& gc, CL_ResourceManager& resmgr, const CL_String& tileset)
: map_width(0), map_height(0), cur_map_x(0), cur_map_y(0) {
CL_Resource res = resmgr.get_resource(tileset);
if (res.get_type() != "tilemap")
throw CL_Exception(cl_format("Resource %1 is not a tilemap", tileset));
CL_DomElement element = res.get_element();
levelname = element.get_attribute("name");
CL_String resource_name = element.get_attribute("resource");
map_width = element.get_attribute_int("width");
map_height = element.get_attribute_int("height");
tiles = CL_Sprite(gc, resource_name, &resmgr);
float scalex, scaley;
tiles.get_scale(scalex, scaley);
tile_width = tiles.get_width() * scalex;
tile_height = tiles.get_height() * scaley;
auto layer_nodes = element.select_nodes("layer");
for (CL_DomNode& idx : layer_nodes) {
CL_DomElement layer_element = idx.to_element();
CL_String layer_tiles = layer_element.get_first_child().get_node_value();
std::vector<CL_String> tile_indices = CL_StringHelp::split_text(layer_tiles, ",");
MapLayer layer;
layer.map.reserve(tile_indices.size());
for (auto& tile : tile_indices)
layer.map.push_back(CL_StringHelp::text_to_int(tile));
layers.push_back(layer);
}
}
void CL_Thread::start(CL_Runnable *runnable)
{
if (runnable == 0)
throw CL_Exception("Invalid runnable pointer");
impl->start(runnable);
}
CL_RegistryKey CL_RegistryKey::open_key(const CL_StringRef &subkey, unsigned int access_rights)
{
HKEY new_key = 0;
LONG result = RegOpenKeyEx(impl->key, CL_StringHelp::utf8_to_ucs2(subkey).c_str(), 0, access_rights, &new_key);
if (result != ERROR_SUCCESS)
throw CL_Exception(cl_format("Unable to open registry key %1", subkey));
return CL_RegistryKey(new_key);
}
CL_RegistryKey::CL_RegistryKey(PredefinedKey key, const CL_StringRef &subkey, unsigned int access_rights, unsigned int create_flags)
{
HKEY hkey = CL_RegistryKey_Impl::get_predefined_hkey(key);
DWORD disposition = 0;
HKEY new_key = 0;
LONG result = RegCreateKeyEx(hkey, CL_StringHelp::utf8_to_ucs2(subkey).c_str(), 0, 0, (create_flags & create_volatile) ? REG_OPTION_VOLATILE : REG_OPTION_NON_VOLATILE, access_rights, 0, &new_key, &disposition);
if (result != ERROR_SUCCESS)
throw CL_Exception(cl_format("Unable to create registry key %1", subkey));
if (disposition != REG_CREATED_NEW_KEY && (create_flags & create_new))
{
RegCloseKey(new_key);
throw CL_Exception(cl_format("Key already exists: %1", subkey));
}
impl = CL_SharedPtr<CL_RegistryKey_Impl>(new CL_RegistryKey_Impl(new_key));
}
CL_GL1CreationHelper::CL_GL1CreationHelper(HWND window, HDC hdc)
: window(window), hdc(hdc), query_window(0), query_dc(0), query_context(0)
{
WINDOWINFO window_info;
memset(&window_info, 0, sizeof(WINDOWINFO));
window_info.cbSize = sizeof(WINDOWINFO);
GetWindowInfo(window, &window_info);
query_window = CreateWindowEx(
0,
WC_STATIC,
TEXT(""),
WS_CHILD,
window_info.rcWindow.left,
window_info.rcWindow.top,
window_info.rcWindow.right - window_info.rcWindow.left,
window_info.rcWindow.bottom - window_info.rcWindow.top,
window, 0, GetModuleHandle(0), 0);
if (query_window == 0)
throw CL_Exception("Unable to create OpenGL creation query window");
query_dc = GetDC(query_window);
if (query_dc == 0)
{
DestroyWindow(query_window);
throw CL_Exception("Unable to retrieve OpenGL creation query device context");
}
PIXELFORMATDESCRIPTOR pfd;
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
int pixelformat = ChoosePixelFormat(query_dc, &pfd);
SetPixelFormat(query_dc, pixelformat, &pfd);
query_context = wglCreateContext(query_dc);
if (query_context == 0)
{
DeleteDC(query_dc);
DestroyWindow(query_window);
throw CL_Exception("Unable to create OpenGL context for creation query window");
}
}
CL_InputContext& CL_GUIWindowManagerProvider_System::get_ic(CL_GUITopLevelWindow *handle) const
{
std::map<CL_GUITopLevelWindow *, CL_GUITopLevelWindowSystem *>::const_iterator it = window_map.find(handle);
if (it == window_map.end())
throw CL_Exception("Cannot find window handle");
return it->second->window.get_ic();
}
void WorkerGC::Start(const CL_StringRef &name)
{
if (worker_thread_processing)
throw CL_Exception("You forgot to get the result");
worker_thread_processing = true;
sprite_name = name;
event_start.set();
}
