Lines Matching defs:size
302 // - Note that pcmd->ClipRect contains Min+Max bounds. Some graphics API may use Min+Max, other may use Min+Size (size being Max-Min)
454 - changed prototype of rarely used 'ColorButton(ImVec4 col, bool small_height = false, bool outline_border = true)' to 'ColorButton(const char* desc_id, ImVec4 col, ImGuiColorEditFlags flags = 0, ImVec2 size = ImVec2(0,0))'
507 - 2015/06/14 (1.41) - changed Selectable() API from (label, selected, size) to (label, selected, flags, size). Size override should have been rarely be used. Sorry!
779 Default is ProggyClean.ttf, monospace, rendered at size 13, embedded in dear imgui's source code.
970 #pragma GCC diagnostic ignored "-Wint-to-pointer-cast" // warning: cast to pointer from integer of different size
995 static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags);
1064 static void* MallocWrapper(size_t size, void* user_data) { IM_UNUSED(user_data); return malloc(size); }
1067 static void* MallocWrapper(size_t size, void* user_data) { IM_UNUSED(user_data); IM_UNUSED(size); IM_ASSERT(0); return NULL; }
1071 static void* (*GImAllocatorAllocFunc)(size_t size, void* user_data) = MallocWrapper;
1085 WindowMinSize = ImVec2(32,32); // Minimum window size
1393 // B) When buf==NULL vsnprintf() will return the output size.
1463 // Known size hash
2742 // Advance cursor given item size for layout.
2743 void ImGui::ItemSize(const ImVec2& size, float text_offset_y)
2751 const float line_height = ImMax(window->DC.CurrentLineSize.y, size.y);
2753 //if (g.IO.KeyAlt) window->DrawList->AddRect(window->DC.CursorPos, window->DC.CursorPos + ImVec2(size.x, line_height), IM_COL32(255,0,0,200)); // [DEBUG]
2754 window->DC.CursorPosPrevLine = ImVec2(window->DC.CursorPos.x + size.x, window->DC.CursorPos.y);
2776 // Note that the size can be different than the one provided to ItemSize(). Typically, widgets that spread over available surface
2777 // declare their minimum size requirement to ItemSize() and then use a larger region for drawing/interaction, which is passed to ItemAdd().
2926 ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_x, float default_y)
2930 if (size.x < 0.0f || size.y < 0.0f)
2932 if (size.x <= 0.0f)
2933 size.x = (size.x == 0.0f) ? default_x : ImMax(content_max.x - g.CurrentWindow->DC.CursorPos.x, 4.0f) + size.x;
2934 if (size.y <= 0.0f)
2935 size.y = (size.y == 0.0f) ? default_y : ImMax(content_max.y - g.CurrentWindow->DC.CursorPos.y, 4.0f) + size.y;
2936 return size;
2953 void* ImGui::MemAlloc(size_t size)
2957 return GImAllocatorAllocFunc(size, GImAllocatorUserData);
3676 // B) If you need/want meshes with more than 64K vertices, uncomment the '#define ImDrawIdx unsigned int' line in imconfig.h to set the index size to 4 bytes.
3677 // You'll need to handle the 4-bytes indices to your renderer. For example, the OpenGL example code detect index size at compile-time by doing:
3712 int size = n;
3714 size += Layers[i].Size;
3715 Layers[0].resize(size);
3896 // Calculate text size. Text can be multi-line. Optionally ignore text after a ## marker.
4331 ImVec2 size = ImFloor(size_arg);
4332 const int auto_fit_axises = ((size.x == 0.0f) ? (1 << ImGuiAxis_X) : 0x00) | ((size.y == 0.0f) ? (1 << ImGuiAxis_Y) : 0x00);
4333 if (size.x <= 0.0f)
4334 size.x = ImMax(content_avail.x + size.x, 4.0f); // Arbitrary minimum child size (0.0f causing too much issues)
4335 if (size.y <= 0.0f)
4336 size.y = ImMax(content_avail.y + size.y, 4.0f);
4337 SetNextWindowSize(size);
4397 if (window->AutoFitChildAxises & (1 << ImGuiAxis_X)) // Arbitrary minimum zero-ish child size of 4.0f causes less trouble than a 0.0f
4424 bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags)
4432 bool ret = BeginChild(id, size, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysUseWindowPadding | extra_flags);
4478 static ImGuiWindow* CreateNewWindow(const char* name, ImVec2 size, ImGuiWindowFlags flags)
4500 size = ImFloor(settings->Size);
4502 window->Size = window->SizeFull = window->SizeFullAtLastBegin = ImFloor(size);
4532 // Using -1,-1 on either X/Y axis to preserve the current size.
4548 // Minimum size
4582 // Maximum window size is determined by the display size
4586 if (is_popup || is_menu) // Popups and menus bypass style.WindowMinSize by default, but we give then a non-zero minimum size to facilitate understanding problematic cases (e.g. empty popups)
4591 // we are growing the size on the other axis to compensate for expected scrollbar. FIXME: Might turn bigger than ViewportSize-WindowPadding.
4740 // We don't use an incremental MouseDelta but rather compute an absolute target size based on mouse position
4787 // FIXME-NAV: Should store and accumulate into a separate size buffer to handle sizing constraints properly, right now a constraint will make us stuck.
4792 // Apply back modified position/size to window
4941 // May be processed on the next frame if this is our first frame and we are measuring size
4960 // Adjust passed "client size" to become a "window size"
5005 // Update contents size from last frame for auto-fitting (or use explicit size)
5012 // Hide new windows for one frame until they calculate their size
5016 // Hide popup/tooltip window when re-opening while we measure size (because we recycle the windows)
5017 // We reset Size/SizeContents for reappearing popups/tooltips early in this function, so further code won't be tempted to use the old size.
5033 // Lock border size and padding for the frame (so that altering them doesn't cause inconsistencies)
5064 // Calculate auto-fit size, handle automatic resize
5087 // Apply minimum/maximum window size constraints and final size
5096 // When reading the current size we need to read it after size constraints have been applied
5182 // Default item width. Make it proportional to window size if window manually resizes
5260 menu_bar_rect.ClipWith(window->Rect()); // Soft clipping, in particular child window don't have minimum size covering the menu bar so this is useful for them.
5405 clip_rect.Max.x = window->Pos.x + window->Size.x - (p_open ? title_bar_rect.GetHeight() - 3 : style.FramePadding.x); // Match the size of CloseButton()
5491 // Old API feature: we could pass the initial window size as a parameter. This was misleading because it only had an effect if the window didn't have data in the .ini file.
6062 window->DC.CursorMaxPos += (window->Pos - old_pos); // And more importantly we need to adjust this so size calculation doesn't get affected.
6083 void ImGui::SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond)
6093 if (size.x > 0.0f)
6096 window->SizeFull.x = ImFloor(size.x);
6103 if (size.y > 0.0f)
6106 window->SizeFull.y = ImFloor(size.y);
6115 void ImGui::SetWindowSize(const ImVec2& size, ImGuiCond cond)
6117 SetWindowSize(GImGui->CurrentWindow, size, cond);
6120 void ImGui::SetWindowSize(const char* name, const ImVec2& size, ImGuiCond cond)
6123 SetWindowSize(window, size, cond);
6187 void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)
6191 g.NextWindowData.SizeVal = size;
6204 void ImGui::SetNextWindowContentSize(const ImVec2& size)
6207 g.NextWindowData.ContentSizeVal = size; // In Begin() we will add the size of window decorations (title bar, menu etc.) to that to form a SizeContents value.
6421 // We store a target position so centering can occur on the next frame when we are guaranteed to have a known window size
6529 bool ImGui::IsRectVisible(const ImVec2& size)
6532 return window->ClipRect.Overlaps(ImRect(window->DC.CursorPos, window->DC.CursorPos + size));
6778 // would become completely unusable because the popup will always be in hidden-while-calculating-size state _while_ claiming focus. Which would be a very confusing
6918 if (!is_open) // NB: Begin can return false when the popup is completely clipped (e.g. zero size display)
6956 if (!is_open || (p_open && !*p_open)) // NB: is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
7021 // r_outer = the visible area rectangle, minus safe area padding. If our popup size won't fit because of safe area padding we ignore it.
7022 ImVec2 ImGui::FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy)
7024 ImVec2 base_pos_clamped = ImClamp(ref_pos, r_outer.Min, r_outer.Max - size);
7039 if (dir == ImGuiDir_Right) pos = ImVec2(r_avoid.Min.x, r_avoid.Min.y - size.y); // Above, Toward Right
7040 if (dir == ImGuiDir_Left) pos = ImVec2(r_avoid.Max.x - size.x, r_avoid.Max.y); // Below, Toward Left
7041 if (dir == ImGuiDir_Up) pos = ImVec2(r_avoid.Max.x - size.x, r_avoid.Min.y - size.y); // Above, Toward Left
7042 if (!r_outer.Contains(ImRect(pos, pos + size)))
7058 if (avail_w < size.x || avail_h < size.y)
7061 pos.x = (dir == ImGuiDir_Left) ? r_avoid.Min.x - size.x : (dir == ImGuiDir_Right) ? r_avoid.Max.x : base_pos_clamped.x;
7062 pos.y = (dir == ImGuiDir_Up) ? r_avoid.Min.y - size.y : (dir == ImGuiDir_Down) ? r_avoid.Max.y : base_pos_clamped.y;
7070 pos.x = ImMax(ImMin(pos.x + size.x, r_outer.Max.x) - size.x, r_outer.Min.x);
7071 pos.y = ImMax(ImMin(pos.y + size.y, r_outer.Max.y) - size.y, r_outer.Min.y);
8907 if (g.LogClipboard.size() > 1)
9096 *out_size = (size_t)g.SettingsIniData.size();
9142 buf->reserve(buf->size() + g.SettingsWindows.Size * 96); // ballpark reserve