//----------------------------------------------------------------------------// bool WindowRenderer::contentFits() const { throw InvalidRequestException("This function isn't implemented for this type of window renderer."); }
//----------------------------------------------------------------------------// float WidgetDim::getValue(const Window& wnd) const { const Window* widget; // if target widget name is empty, then use the input window. if (d_widgetName.empty()) { widget = &wnd; } // name not empty, so find window with required name else { widget = wnd.getChild(d_widgetName); } // get size of parent; required to extract pixel values Sizef parentSize(widget->getParentPixelSize()); switch (d_what) { case DT_WIDTH: return widget->getPixelSize().d_width; break; case DT_HEIGHT: return widget->getPixelSize().d_height; break; case DT_X_OFFSET: Logger::getSingleton().logEvent("WigetDim::getValue - Nonsensical DimensionType of DT_X_OFFSET specified! returning 0.0f"); return 0.0f; break; case DT_Y_OFFSET: Logger::getSingleton().logEvent("WigetDim::getValue - Nonsensical DimensionType of DT_Y_OFFSET specified! returning 0.0f"); return 0.0f; break; case DT_LEFT_EDGE: case DT_X_POSITION: return CoordConverter::asAbsolute(widget->getPosition().d_x, parentSize.d_width); break; case DT_TOP_EDGE: case DT_Y_POSITION: return CoordConverter::asAbsolute(widget->getPosition().d_y, parentSize.d_height); break; case DT_RIGHT_EDGE: return CoordConverter::asAbsolute(widget->getArea().d_max.d_x, parentSize.d_width); break; case DT_BOTTOM_EDGE: return CoordConverter::asAbsolute(widget->getArea().d_max.d_y, parentSize.d_height); break; default: CEGUI_THROW(InvalidRequestException( "unknown or unsupported DimensionType encountered.")); break; } }
//----------------------------------------------------------------------------// UDim WindowRenderer::getHeightOfAreaReservedForContentLowerBoundAsFuncOfWindowHeight() const { throw InvalidRequestException("This function isn't implemented for this type of window renderer."); }
//----------------------------------------------------------------------------// bool WindowRenderer::contentFitsForSpecifiedWindowSize(const Sizef& /*window_size*/) const { throw InvalidRequestException("This function isn't implemented for this type of window renderer."); }
/************************************************************************* Load all resources for this scheme *************************************************************************/ void Scheme::loadResources(void) { Logger::getSingleton().logEvent((utf8*)"---- Begining resource loading for GUI scheme '" + d_name + "' ----", Informative); ImagesetManager& ismgr = ImagesetManager::getSingleton(); FontManager& fntmgr = FontManager::getSingleton(); WindowFactoryManager& wfmgr = WindowFactoryManager::getSingleton(); WidgetLookManager& wlfMgr = WidgetLookManager::getSingleton(); std::vector<LoadableUIElement>::const_iterator pos; // check imagesets for (pos = d_imagesets.begin(); pos != d_imagesets.end(); ++pos) { if (!ismgr.isImagesetPresent((*pos).name)) { Imageset* iset = ismgr.createImageset((*pos).filename, (*pos).resourceGroup); // check for wrong imageset for specified name String realname = iset->getName(); if (realname != (*pos).name) { ismgr.destroyImageset(iset); throw InvalidRequestException((utf8*)"Scheme::loadResources - The Imageset created by file '" + (*pos).filename + "' is named '" + realname + "', not '" + (*pos).name + "' as required by Scheme '" + d_name + "'."); } } } // check imagesets that are created directly from image files for (pos = d_imagesetsFromImages.begin(); pos != d_imagesetsFromImages.end(); ++pos) { if (!ismgr.isImagesetPresent((*pos).name)) ismgr.createImagesetFromImageFile((*pos).name, (*pos).filename, (*pos).resourceGroup); } // check fonts for (pos = d_fonts.begin(); pos != d_fonts.end(); ++pos) { if (!fntmgr.isFontPresent((*pos).name)) { Font* font = fntmgr.createFont((*pos).filename, (*pos).resourceGroup); // check for wrong font for specified name String realname = font->getName(); if (realname != (*pos).name) { fntmgr.destroyFont(font); throw InvalidRequestException((utf8*)"Scheme::loadResources - The Font created by file '" + (*pos).filename + "' is named '" + realname + "', not '" + (*pos).name + "' as required by Scheme '" + d_name + "'."); } } } // load look'n'feels (can't actually check these, so just re-parse data; it does no harm except maybe wase a bit of time) for (pos = d_looknfeels.begin(); pos != d_looknfeels.end(); ++pos) { wlfMgr.parseLookNFeelSpecification((*pos).filename, (*pos).resourceGroup); } // check factories std::vector<UIModule>::iterator cmod = d_widgetModules.begin(); for (; cmod != d_widgetModules.end(); ++cmod) { // create and load dynamic module as required if ((*cmod).module == NULL) { (*cmod).module = new FactoryModule((*cmod).name); } // see if we should just register all factories available in the module (i.e. No factories explicitly specified) if ((*cmod).factories.size() == 0) { Logger::getSingleton().logEvent("No window factories specified for module '" + (*cmod).name + "' - adding all available factories..."); (*cmod).module->registerAllFactories(); } // some names were explicitly given, so only register those. else { std::vector<UIElementFactory>::const_iterator elem = (*cmod).factories.begin(); for (; elem != (*cmod).factories.end(); ++elem) { if (!wfmgr.isFactoryPresent((*elem).name)) { (*cmod).module->registerFactory((*elem).name); } } } } // check aliases std::vector<AliasMapping>::iterator alias = d_aliasMappings.begin(); for (; alias != d_aliasMappings.end(); ++alias) { // get iterator WindowFactoryManager::TypeAliasIterator iter = wfmgr.getAliasIterator(); // look for this alias while (!iter.isAtEnd() && (iter.getCurrentKey() != (*alias).aliasName)) ++iter; // if the alias exists if (!iter.isAtEnd()) { // if the current target type matches if (iter.getCurrentValue().getActiveTarget() == (*alias).targetName) { // assume this mapping is ours and skip to next alias continue; } } // create a new alias entry wfmgr.addWindowTypeAlias((*alias).aliasName, (*alias).targetName); } // check falagard window mappings. std::vector<FalagardMapping>::iterator falagard = d_falagardMappings.begin(); for (; falagard != d_falagardMappings.end(); ++falagard) { // get iterator WindowFactoryManager::FalagardMappingIterator iter = wfmgr.getFalagardMappingIterator(); // look for this mapping while (!iter.isAtEnd() && (iter.getCurrentKey() != (*falagard).windowName)) ++iter; // if the alias exists if (!iter.isAtEnd()) { // if the current target and looks match if ((iter.getCurrentValue().d_baseType == (*falagard).targetName) && (iter.getCurrentValue().d_lookName == (*falagard).lookName)) { // assume this mapping is ours and skip to next continue; } } // create a new mapping entry wfmgr.addFalagardWindowMapping((*falagard).windowName, (*falagard).targetName, (*falagard).lookName); } Logger::getSingleton().logEvent((utf8*)"---- Resource loading for GUI scheme '" + d_name + "' completed ----", Informative); }
//----------------------------------------------------------------------------// float WindowRenderer::getContentHeight() const { throw InvalidRequestException("This function isn't implemented for this type of window renderer."); }
//----------------------------------------------------------------------------// void RenderedStringImageComponent::draw(const Window* ref_wnd, std::vector<GeometryBuffer*>& geometry_buffers, const glm::vec2& position, const ColourRect* mod_colours, const Rectf* clip_rect, const float vertical_space, const float /*space_extra*/) const { if (!d_image) return; Rectf dest(position.x, position.y, 0, 0); float y_scale = 1.0f; // handle formatting options switch (d_verticalFormatting) { case VF_BOTTOM_ALIGNED: dest.d_min.y += vertical_space - getPixelSize(ref_wnd).d_height; break; case VF_CENTRE_ALIGNED: dest.d_min.y += (vertical_space - getPixelSize(ref_wnd).d_height) / 2 ; break; case VF_STRETCHED: y_scale = vertical_space / getPixelSize(ref_wnd).d_height; break; case VF_TOP_ALIGNED: // nothing additional to do for this formatting option. break; default: throw InvalidRequestException( "unknown VerticalFormatting option specified."); } Sizef sz(d_image->getRenderedSize()); if (d_size.d_width != 0.0) sz.d_width = d_size.d_width; if (d_size.d_height != 0.0) sz.d_height = d_size.d_height; sz.d_height *= y_scale; dest.setSize(sz); // apply padding to position dest.offset(d_padding.getPosition()); // render the selection if needed if (d_selectionImage && d_selected) { const Rectf select_area(position, getPixelSize(ref_wnd)); d_selectionImage->render(geometry_buffers, select_area, clip_rect, true, ColourRect(0xFF002FFF)); } // apply modulative colours if needed. ColourRect final_cols(d_colours); if (mod_colours) final_cols *= *mod_colours; // draw the image. d_image->render(geometry_buffers, dest, clip_rect, true, final_cols); }
//----------------------------------------------------------------------------// RenderedStringImageComponent* RenderedStringImageComponent::split( const Window* /*ref_wnd*/ ,float /*split_point*/, bool /*first_component*/) { throw InvalidRequestException( "this component does not support being split."); }
void FrameComponent::doBackgroundRender(Window& srcWindow, Rect& destRect, float base_z, const ColourRect& colours, const Rect* clipper, bool clipToDisplay) const { HorizontalFormatting horzFormatting = d_horzFormatPropertyName.empty() ? d_horzFormatting : FalagardXMLHelper::stringToHorzFormat(srcWindow.getProperty(d_horzFormatPropertyName)); VerticalFormatting vertFormatting = d_vertFormatPropertyName.empty() ? d_vertFormatting : FalagardXMLHelper::stringToVertFormat(srcWindow.getProperty(d_vertFormatPropertyName)); uint horzTiles, vertTiles; float xpos, ypos; Size imgSz(d_frameImages[FIC_BACKGROUND]->getSize()); // calculate initial x co-ordinate and horizontal tile count according to formatting options switch (horzFormatting) { case HF_STRETCHED: imgSz.d_width = destRect.getWidth(); xpos = destRect.d_left; horzTiles = 1; break; case HF_TILED: xpos = destRect.d_left; horzTiles = (uint)((destRect.getWidth() + (imgSz.d_width - 1)) / imgSz.d_width); break; case HF_LEFT_ALIGNED: xpos = destRect.d_left; horzTiles = 1; break; case HF_CENTRE_ALIGNED: xpos = destRect.d_left + PixelAligned((destRect.getWidth() - imgSz.d_width) * 0.5f); horzTiles = 1; break; case HF_RIGHT_ALIGNED: xpos = destRect.d_right - imgSz.d_width; horzTiles = 1; break; default: throw InvalidRequestException("FrameComponent::doBackgroundRender - An unknown HorizontalFormatting value was specified."); } // calculate initial y co-ordinate and vertical tile count according to formatting options switch (vertFormatting) { case VF_STRETCHED: imgSz.d_height = destRect.getHeight(); ypos = destRect.d_top; vertTiles = 1; break; case VF_TILED: ypos = destRect.d_top; vertTiles = (uint)((destRect.getHeight() + (imgSz.d_height - 1)) / imgSz.d_height); break; case VF_TOP_ALIGNED: ypos = destRect.d_top; vertTiles = 1; break; case VF_CENTRE_ALIGNED: ypos = destRect.d_top + PixelAligned((destRect.getHeight() - imgSz.d_height) * 0.5f); vertTiles = 1; break; case VF_BOTTOM_ALIGNED: ypos = destRect.d_bottom - imgSz.d_height; vertTiles = 1; break; default: throw InvalidRequestException("FrameComponent::doBackgroundRender - An unknown VerticalFormatting value was specified."); } // perform final rendering (actually is now a caching of the images which will be drawn) Rect finalRect; Rect finalClipper; const Rect* clippingRect; finalRect.d_top = ypos; finalRect.d_bottom = ypos + imgSz.d_height; for (uint row = 0; row < vertTiles; ++row) { finalRect.d_left = xpos; finalRect.d_right = xpos + imgSz.d_width; for (uint col = 0; col < horzTiles; ++col) { // use custom clipping for right and bottom edges when tiling the imagery if (((vertFormatting == VF_TILED) && row == vertTiles - 1) || ((horzFormatting == HF_TILED) && col == horzTiles - 1)) { finalClipper = clipper ? clipper->getIntersection(destRect) : destRect; clippingRect = &finalClipper; } // not tiliing, or not on far edges, just used passed in clipper (if any). else { clippingRect = clipper; } // add image to the rendering cache for the target window. srcWindow.getRenderCache().cacheImage(*d_frameImages[FIC_BACKGROUND], finalRect, base_z, colours, clippingRect, clipToDisplay); finalRect.d_left += imgSz.d_width; finalRect.d_right += imgSz.d_width; } finalRect.d_top += imgSz.d_height; finalRect.d_bottom += imgSz.d_height; } }
//----------------------------------------------------------------------------// void MinizipResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { const String final_filename = getFinalFilename(filename, resourceGroup); if (d_pimpl->d_loadLocal && doesFileExist(final_filename)) { DefaultResourceProvider::loadRawDataContainer(filename, output, resourceGroup); return; } if (d_pimpl->d_zfile == 0) { throw InvalidRequestException( "'" + final_filename + "' cannot be " "loaded because the archive has not been set"); } #if CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_STD if (unzLocateFile(d_pimpl->d_zfile, final_filename.c_str(), 0) != UNZ_OK) #elif CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_UNICODE if (unzLocateFile(d_pimpl->d_zfile, final_filename.toUtf8String().c_str(), 0) != UNZ_OK) #endif { throw InvalidRequestException("'" + final_filename + "' does not exist"); } unz_file_info file_info; if (unzGetCurrentFileInfo(d_pimpl->d_zfile, &file_info, 0, 0, 0, 0, 0, 0) != UNZ_OK) { throw FileIOException("'" + final_filename + "' error reading file header"); } if (unzOpenCurrentFile(d_pimpl->d_zfile) != Z_OK) { throw FileIOException("'" + final_filename + "' error opening file"); } std::uint64_t size = file_info.uncompressed_size; std::uint8_t* buffer = new std::uint8_t[size]; if (unzReadCurrentFile(d_pimpl->d_zfile, buffer, size) < 0) { throw FileIOException("'" + final_filename + "' error reading file"); } if (unzCloseCurrentFile(d_pimpl->d_zfile) != UNZ_OK) { throw GenericException("'" + final_filename + "' error validating file"); } output.setData(buffer); output.setSize(size); }
//----------------------------------------------------------------------------// RenderedStringTextComponent* RenderedStringTextComponent::split( const Window* ref_wnd, float split_point, bool first_component) { const Font* fnt = getEffectiveFont(ref_wnd); // This is checked, but should never fail, since if we had no font our // extent would be 0 and we would never cause a split to be needed here. if (!fnt) CEGUI_THROW(InvalidRequestException( "unable to split with no font set.")); // create 'left' side of split and clone our basic configuration RenderedStringTextComponent* lhs = CEGUI_NEW_AO RenderedStringTextComponent(); lhs->d_padding = d_padding; lhs->d_verticalFormatting = d_verticalFormatting; lhs->d_font = d_font; lhs->d_colours = d_colours; // calculate the 'best' place to split the text size_t left_len = 0; float left_extent = 0.0f; while (left_len < d_text.length()) { size_t token_len = getNextTokenLength(d_text, left_len); // exit loop if no more valid tokens. if (token_len == 0) break; const float token_extent = fnt->getTextExtent(d_text.substr(left_len, token_len)); // does the next token extend past the split point? if (left_extent + token_extent > split_point) { // if it was the first token, split the token itself if (first_component && left_len == 0) left_len = ceguimax(static_cast<size_t>(1), fnt->getCharAtPixel( d_text.substr(0, token_len), split_point)); // left_len is now the character index at which to split the line break; } // add this token to the left side left_len += token_len; left_extent += token_extent; } // perform the split. lhs->d_text = d_text.substr(0, left_len); // here we're trimming leading delimiters from the substring range size_t rhs_start = d_text.find_first_not_of(TextUtils::DefaultWrapDelimiters, left_len); if (rhs_start == String::npos) rhs_start = left_len; // split the selection if (d_selectionLength) { const size_t sel_end = d_selectionStart + d_selectionLength - 1; lhs->d_selectionStart = d_selectionStart; lhs->d_selectionLength = sel_end < left_len ? d_selectionLength : left_len - d_selectionStart; if (sel_end >= left_len) { d_selectionStart = 0; d_selectionLength -= rhs_start; } else setSelection(ref_wnd, 0, 0); } d_text = d_text.substr(rhs_start); return lhs; }
//----------------------------------------------------------------------------// void RenderedStringTextComponent::draw(const Window* ref_wnd, GeometryBuffer& buffer, const Vector2f& position, const ColourRect* mod_colours, const Rectf* clip_rect, const float vertical_space, const float space_extra) const { const Font* fnt = getEffectiveFont(ref_wnd); if (!fnt) return; Vector2f final_pos(position); float y_scale = 1.0f; // handle formatting options switch (d_verticalFormatting) { case VF_BOTTOM_ALIGNED: final_pos.d_y += vertical_space - getPixelSize(ref_wnd).d_height; break; case VF_CENTRE_ALIGNED: final_pos.d_y += (vertical_space - getPixelSize(ref_wnd).d_height) / 2 ; break; case VF_STRETCHED: y_scale = vertical_space / getPixelSize(ref_wnd).d_height; break; case VF_TOP_ALIGNED: // nothing additional to do for this formatting option. break; default: CEGUI_THROW(InvalidRequestException( "unknown VerticalFormatting option specified.")); } // apply padding to position: final_pos += d_padding.getPosition(); // apply modulative colours if needed. ColourRect final_cols(d_colours); if (mod_colours) final_cols *= *mod_colours; // render selection if (d_selectionImage && d_selectionLength) { float sel_start_extent = 0, sel_end_extent = 0; if (d_selectionStart > 0) sel_start_extent = fnt->getTextExtent(d_text.substr(0, d_selectionStart)); sel_end_extent = fnt->getTextExtent(d_text.substr(0, d_selectionStart + d_selectionLength)); Rectf sel_rect(position.d_x + sel_start_extent, position.d_y, position.d_x + sel_end_extent, position.d_y + vertical_space); d_selectionImage->render(buffer, sel_rect, clip_rect, ColourRect(0xFF002FFF)); } // draw the text string. fnt->drawText(buffer, d_text, final_pos, clip_rect, final_cols, space_extra, 1.0f, y_scale); }
//----------------------------------------------------------------------------// void FrameComponent::renderImage(std::vector<GeometryBuffer*>& geometry_buffers, const Image* image, VerticalFormatting vertFmt, HorizontalFormatting horzFmt, Rectf& destRect, const ColourRect& colours, const Rectf* clipper, bool clip_to_display) const { uint horzTiles, vertTiles; float xpos, ypos; Sizef imgSz(image->getRenderedSize()); // calculate initial x co-ordinate and horizontal tile count according to formatting options switch (horzFmt) { case HF_STRETCHED: imgSz.d_width = destRect.getWidth(); xpos = destRect.left(); horzTiles = 1; break; case HF_TILED: xpos = destRect.left(); horzTiles = std::abs(static_cast<int>( (destRect.getWidth() + (imgSz.d_width - 1)) / imgSz.d_width)); break; case HF_LEFT_ALIGNED: xpos = destRect.left(); horzTiles = 1; break; case HF_CENTRE_ALIGNED: xpos = destRect.left() + CoordConverter::alignToPixels((destRect.getWidth() - imgSz.d_width) * 0.5f); horzTiles = 1; break; case HF_RIGHT_ALIGNED: xpos = destRect.right() - imgSz.d_width; horzTiles = 1; break; default: CEGUI_THROW(InvalidRequestException( "An unknown HorizontalFormatting value was specified.")); } // calculate initial y co-ordinate and vertical tile count according to formatting options switch (vertFmt) { case VF_STRETCHED: imgSz.d_height = destRect.getHeight(); ypos = destRect.top(); vertTiles = 1; break; case VF_TILED: ypos = destRect.top(); vertTiles = std::abs(static_cast<int>( (destRect.getHeight() + (imgSz.d_height - 1)) / imgSz.d_height)); break; case VF_TOP_ALIGNED: ypos = destRect.top(); vertTiles = 1; break; case VF_CENTRE_ALIGNED: ypos = destRect.top() + CoordConverter::alignToPixels((destRect.getHeight() - imgSz.d_height) * 0.5f); vertTiles = 1; break; case VF_BOTTOM_ALIGNED: ypos = destRect.bottom() - imgSz.d_height; vertTiles = 1; break; default: CEGUI_THROW(InvalidRequestException( "An unknown VerticalFormatting value was specified.")); } // perform final rendering (actually is now a caching of the images which will be drawn) Rectf finalRect; Rectf finalClipper; const Rectf* clippingRect; finalRect.d_min.d_y = ypos; finalRect.d_max.d_y = ypos + imgSz.d_height; for (uint row = 0; row < vertTiles; ++row) { finalRect.d_min.d_x = xpos; finalRect.d_max.d_x = xpos + imgSz.d_width; for (uint col = 0; col < horzTiles; ++col) { // use custom clipping for right and bottom edges when tiling the imagery if (((vertFmt == VF_TILED) && row == vertTiles - 1) || ((horzFmt == HF_TILED) && col == horzTiles - 1)) { finalClipper = clipper ? clipper->getIntersection(destRect) : destRect; clippingRect = &finalClipper; } // not tiliing, or not on far edges, just used passed in clipper (if any). else clippingRect = clipper; image->render(geometry_buffers, finalRect, clippingRect, !clip_to_display, colours); finalRect.d_min.d_x += imgSz.d_width; finalRect.d_max.d_x += imgSz.d_width; } finalRect.d_min.d_y += imgSz.d_height; finalRect.d_max.d_y += imgSz.d_height; } }