|
|
@@ -74,22 +74,30 @@ Index of this file:
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
// Those MIN/MAX values are not define because we need to point to them
|
|
|
-static const ImS32 IM_S32_MIN = INT_MIN; // (-2147483647 - 1), (0x80000000);
|
|
|
-static const ImS32 IM_S32_MAX = INT_MAX; // (2147483647), (0x7FFFFFFF)
|
|
|
-static const ImU32 IM_U32_MIN = 0;
|
|
|
-static const ImU32 IM_U32_MAX = UINT_MAX; // (0xFFFFFFFF)
|
|
|
+static const char IM_S8_MIN = -128;
|
|
|
+static const char IM_S8_MAX = 127;
|
|
|
+static const unsigned char IM_U8_MIN = 0;
|
|
|
+static const unsigned char IM_U8_MAX = 0xFF;
|
|
|
+static const short IM_S16_MIN = -32768;
|
|
|
+static const short IM_S16_MAX = 32767;
|
|
|
+static const unsigned short IM_U16_MIN = 0;
|
|
|
+static const unsigned short IM_U16_MAX = 0xFFFF;
|
|
|
+static const ImS32 IM_S32_MIN = INT_MIN; // (-2147483647 - 1), (0x80000000);
|
|
|
+static const ImS32 IM_S32_MAX = INT_MAX; // (2147483647), (0x7FFFFFFF)
|
|
|
+static const ImU32 IM_U32_MIN = 0;
|
|
|
+static const ImU32 IM_U32_MAX = UINT_MAX; // (0xFFFFFFFF)
|
|
|
#ifdef LLONG_MIN
|
|
|
-static const ImS64 IM_S64_MIN = LLONG_MIN; // (-9223372036854775807ll - 1ll);
|
|
|
-static const ImS64 IM_S64_MAX = LLONG_MAX; // (9223372036854775807ll);
|
|
|
+static const ImS64 IM_S64_MIN = LLONG_MIN; // (-9223372036854775807ll - 1ll);
|
|
|
+static const ImS64 IM_S64_MAX = LLONG_MAX; // (9223372036854775807ll);
|
|
|
#else
|
|
|
-static const ImS64 IM_S64_MIN = -9223372036854775807LL - 1;
|
|
|
-static const ImS64 IM_S64_MAX = 9223372036854775807LL;
|
|
|
+static const ImS64 IM_S64_MIN = -9223372036854775807LL - 1;
|
|
|
+static const ImS64 IM_S64_MAX = 9223372036854775807LL;
|
|
|
#endif
|
|
|
-static const ImU64 IM_U64_MIN = 0;
|
|
|
+static const ImU64 IM_U64_MIN = 0;
|
|
|
#ifdef ULLONG_MAX
|
|
|
-static const ImU64 IM_U64_MAX = ULLONG_MAX; // (0xFFFFFFFFFFFFFFFFull);
|
|
|
+static const ImU64 IM_U64_MAX = ULLONG_MAX; // (0xFFFFFFFFFFFFFFFFull);
|
|
|
#else
|
|
|
-static const ImU64 IM_U64_MAX = (2ULL * 9223372036854775807LL + 1);
|
|
|
+static const ImU64 IM_U64_MAX = (2ULL * 9223372036854775807LL + 1);
|
|
|
#endif
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
@@ -1526,17 +1534,21 @@ struct ImGuiDataTypeInfo
|
|
|
|
|
|
static const ImGuiDataTypeInfo GDataTypeInfo[] =
|
|
|
{
|
|
|
- { sizeof(int), "%d", "%d" },
|
|
|
- { sizeof(unsigned int), "%u", "%u" },
|
|
|
+ { sizeof(char), "%d", "%d" }, // ImGuiDataType_S8
|
|
|
+ { sizeof(unsigned char), "%u", "%u" },
|
|
|
+ { sizeof(short), "%d", "%d" }, // ImGuiDataType_S16
|
|
|
+ { sizeof(unsigned short), "%u", "%u" },
|
|
|
+ { sizeof(int), "%d", "%d" }, // ImGuiDataType_S32
|
|
|
+ { sizeof(unsigned int), "%u", "%u" },
|
|
|
#ifdef _MSC_VER
|
|
|
- { sizeof(ImS64), "%I64d","%I64d" },
|
|
|
- { sizeof(ImU64), "%I64u","%I64u" },
|
|
|
+ { sizeof(ImS64), "%I64d","%I64d" }, // ImGuiDataType_S64
|
|
|
+ { sizeof(ImU64), "%I64u","%I64u" },
|
|
|
#else
|
|
|
- { sizeof(ImS64), "%lld", "%lld" },
|
|
|
- { sizeof(ImU64), "%llu", "%llu" },
|
|
|
+ { sizeof(ImS64), "%lld", "%lld" }, // ImGuiDataType_S64
|
|
|
+ { sizeof(ImU64), "%llu", "%llu" },
|
|
|
#endif
|
|
|
- { sizeof(float), "%f", "%f" }, // float are promoted to double in va_arg
|
|
|
- { sizeof(double), "%f", "%lf" },
|
|
|
+ { sizeof(float), "%f", "%f" }, // ImGuiDataType_Float (float are promoted to double in va_arg)
|
|
|
+ { sizeof(double), "%f", "%lf" }, // ImGuiDataType_Double
|
|
|
};
|
|
|
IM_STATIC_ASSERT(IM_ARRAYSIZE(GDataTypeInfo) == ImGuiDataType_COUNT);
|
|
|
|
|
|
@@ -1566,47 +1578,71 @@ static const char* PatchFormatStringFloatToInt(const char* fmt)
|
|
|
|
|
|
static inline int DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* data_ptr, const char* format)
|
|
|
{
|
|
|
- if (data_type == ImGuiDataType_S32 || data_type == ImGuiDataType_U32) // Signedness doesn't matter when pushing the argument
|
|
|
+ // Signedness doesn't matter when pushing integer arguments
|
|
|
+ if (data_type == ImGuiDataType_S32 || data_type == ImGuiDataType_U32)
|
|
|
return ImFormatString(buf, buf_size, format, *(const ImU32*)data_ptr);
|
|
|
- if (data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64) // Signedness doesn't matter when pushing the argument
|
|
|
+ if (data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)
|
|
|
return ImFormatString(buf, buf_size, format, *(const ImU64*)data_ptr);
|
|
|
if (data_type == ImGuiDataType_Float)
|
|
|
return ImFormatString(buf, buf_size, format, *(const float*)data_ptr);
|
|
|
if (data_type == ImGuiDataType_Double)
|
|
|
return ImFormatString(buf, buf_size, format, *(const double*)data_ptr);
|
|
|
+ if (data_type == ImGuiDataType_S8)
|
|
|
+ return ImFormatString(buf, buf_size, format, *(const ImS8*)data_ptr);
|
|
|
+ if (data_type == ImGuiDataType_U8)
|
|
|
+ return ImFormatString(buf, buf_size, format, *(const ImU8*)data_ptr);
|
|
|
+ if (data_type == ImGuiDataType_S16)
|
|
|
+ return ImFormatString(buf, buf_size, format, *(const ImS16*)data_ptr);
|
|
|
+ if (data_type == ImGuiDataType_U16)
|
|
|
+ return ImFormatString(buf, buf_size, format, *(const ImU16*)data_ptr);
|
|
|
IM_ASSERT(0);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-// FIXME: Adding support for clamping on boundaries of the data type would be nice.
|
|
|
static void DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, void* arg1, const void* arg2)
|
|
|
{
|
|
|
IM_ASSERT(op == '+' || op == '-');
|
|
|
switch (data_type)
|
|
|
{
|
|
|
+ case ImGuiDataType_S8:
|
|
|
+ if (op == '+') { *(ImS8*)output = ImAddClampOverflow(*(const ImS8*)arg1, *(const ImS8*)arg2, IM_S8_MIN, IM_S8_MAX); }
|
|
|
+ if (op == '-') { *(ImS8*)output = ImSubClampOverflow(*(const ImS8*)arg1, *(const ImS8*)arg2, IM_S8_MIN, IM_S8_MAX); }
|
|
|
+ return;
|
|
|
+ case ImGuiDataType_U8:
|
|
|
+ if (op == '+') { *(ImU8*)output = ImAddClampOverflow(*(const ImU8*)arg1, *(const ImU8*)arg2, IM_U8_MIN, IM_U8_MAX); }
|
|
|
+ if (op == '-') { *(ImU8*)output = ImSubClampOverflow(*(const ImU8*)arg1, *(const ImU8*)arg2, IM_U8_MIN, IM_U8_MAX); }
|
|
|
+ return;
|
|
|
+ case ImGuiDataType_S16:
|
|
|
+ if (op == '+') { *(ImS16*)output = ImAddClampOverflow(*(const ImS16*)arg1, *(const ImS16*)arg2, IM_S16_MIN, IM_S16_MAX); }
|
|
|
+ if (op == '-') { *(ImS16*)output = ImSubClampOverflow(*(const ImS16*)arg1, *(const ImS16*)arg2, IM_S16_MIN, IM_S16_MAX); }
|
|
|
+ return;
|
|
|
+ case ImGuiDataType_U16:
|
|
|
+ if (op == '+') { *(ImU16*)output = ImAddClampOverflow(*(const ImU16*)arg1, *(const ImU16*)arg2, IM_U16_MIN, IM_U16_MAX); }
|
|
|
+ if (op == '-') { *(ImU16*)output = ImSubClampOverflow(*(const ImU16*)arg1, *(const ImU16*)arg2, IM_U16_MIN, IM_U16_MAX); }
|
|
|
+ return;
|
|
|
case ImGuiDataType_S32:
|
|
|
- if (op == '+') *(int*)output = *(const int*)arg1 + *(const int*)arg2;
|
|
|
- else if (op == '-') *(int*)output = *(const int*)arg1 - *(const int*)arg2;
|
|
|
+ if (op == '+') { *(ImS32*)output = ImAddClampOverflow(*(const ImS32*)arg1, *(const ImS32*)arg2, IM_S32_MIN, IM_S32_MAX); }
|
|
|
+ if (op == '-') { *(ImS32*)output = ImSubClampOverflow(*(const ImS32*)arg1, *(const ImS32*)arg2, IM_S32_MIN, IM_S32_MAX); }
|
|
|
return;
|
|
|
case ImGuiDataType_U32:
|
|
|
- if (op == '+') *(unsigned int*)output = *(const unsigned int*)arg1 + *(const ImU32*)arg2;
|
|
|
- else if (op == '-') *(unsigned int*)output = *(const unsigned int*)arg1 - *(const ImU32*)arg2;
|
|
|
+ if (op == '+') { *(ImU32*)output = ImAddClampOverflow(*(const ImU32*)arg1, *(const ImU32*)arg2, IM_U32_MIN, IM_U32_MAX); }
|
|
|
+ if (op == '-') { *(ImU32*)output = ImSubClampOverflow(*(const ImU32*)arg1, *(const ImU32*)arg2, IM_U32_MIN, IM_U32_MAX); }
|
|
|
return;
|
|
|
case ImGuiDataType_S64:
|
|
|
- if (op == '+') *(ImS64*)output = *(const ImS64*)arg1 + *(const ImS64*)arg2;
|
|
|
- else if (op == '-') *(ImS64*)output = *(const ImS64*)arg1 - *(const ImS64*)arg2;
|
|
|
+ if (op == '+') { *(ImS64*)output = ImAddClampOverflow(*(const ImS64*)arg1, *(const ImS64*)arg2, IM_S64_MIN, IM_S64_MAX); }
|
|
|
+ if (op == '-') { *(ImS64*)output = ImSubClampOverflow(*(const ImS64*)arg1, *(const ImS64*)arg2, IM_S64_MIN, IM_S64_MAX); }
|
|
|
return;
|
|
|
case ImGuiDataType_U64:
|
|
|
- if (op == '+') *(ImU64*)output = *(const ImU64*)arg1 + *(const ImU64*)arg2;
|
|
|
- else if (op == '-') *(ImU64*)output = *(const ImU64*)arg1 - *(const ImU64*)arg2;
|
|
|
+ if (op == '+') { *(ImU64*)output = ImAddClampOverflow(*(const ImU64*)arg1, *(const ImU64*)arg2, IM_U64_MIN, IM_U64_MAX); }
|
|
|
+ if (op == '-') { *(ImU64*)output = ImSubClampOverflow(*(const ImU64*)arg1, *(const ImU64*)arg2, IM_U64_MIN, IM_U64_MAX); }
|
|
|
return;
|
|
|
case ImGuiDataType_Float:
|
|
|
- if (op == '+') *(float*)output = *(const float*)arg1 + *(const float*)arg2;
|
|
|
- else if (op == '-') *(float*)output = *(const float*)arg1 - *(const float*)arg2;
|
|
|
+ if (op == '+') { *(float*)output = *(const float*)arg1 + *(const float*)arg2; }
|
|
|
+ if (op == '-') { *(float*)output = *(const float*)arg1 - *(const float*)arg2; }
|
|
|
return;
|
|
|
case ImGuiDataType_Double:
|
|
|
- if (op == '+') *(double*)output = *(const double*)arg1 + *(const double*)arg2;
|
|
|
- else if (op == '-') *(double*)output = *(const double*)arg1 - *(const double*)arg2;
|
|
|
+ if (op == '+') { *(double*)output = *(const double*)arg1 + *(const double*)arg2; }
|
|
|
+ if (op == '-') { *(double*)output = *(const double*)arg1 - *(const double*)arg2; }
|
|
|
return;
|
|
|
case ImGuiDataType_COUNT: break;
|
|
|
}
|
|
|
@@ -1645,6 +1681,7 @@ static bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_b
|
|
|
if (format == NULL)
|
|
|
format = GDataTypeInfo[data_type].ScanFmt;
|
|
|
|
|
|
+ // FIXME-LEGACY: The aim is to remove those operators and write a proper expression evaluator at some point..
|
|
|
int arg1i = 0;
|
|
|
if (data_type == ImGuiDataType_S32)
|
|
|
{
|
|
|
@@ -1659,12 +1696,6 @@ static bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_b
|
|
|
else if (op == '/') { if (sscanf(buf, "%f", &arg1f) && arg1f != 0.0f) *v = (int)(arg0i / arg1f); } // Divide
|
|
|
else { if (sscanf(buf, format, &arg1i) == 1) *v = arg1i; } // Assign constant
|
|
|
}
|
|
|
- else if (data_type == ImGuiDataType_U32 || data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)
|
|
|
- {
|
|
|
- // Assign constant
|
|
|
- // FIXME: We don't bother handling support for legacy operators since they are a little too crappy. Instead we may implement a proper expression evaluator in the future.
|
|
|
- sscanf(buf, format, data_ptr);
|
|
|
- }
|
|
|
else if (data_type == ImGuiDataType_Float)
|
|
|
{
|
|
|
// For floats we have to ignore format with precision (e.g. "%.2f") because sscanf doesn't take them in
|
|
|
@@ -1694,6 +1725,29 @@ static bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_b
|
|
|
else if (op == '/') { if (arg1f != 0.0f) *v = arg0f / arg1f; } // Divide
|
|
|
else { *v = arg1f; } // Assign constant
|
|
|
}
|
|
|
+ else if (data_type == ImGuiDataType_U32 || data_type == ImGuiDataType_S64 || data_type == ImGuiDataType_U64)
|
|
|
+ {
|
|
|
+ // All other types assign constant
|
|
|
+ // We don't bother handling support for legacy operators since they are a little too crappy. Instead we will later implement a proper expression evaluator in the future.
|
|
|
+ sscanf(buf, format, data_ptr);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Small types need a 32-bit buffer to receive the result from scanf()
|
|
|
+ int v32;
|
|
|
+ sscanf(buf, format, &v32);
|
|
|
+ if (data_type == ImGuiDataType_S8)
|
|
|
+ *(ImS8*)data_ptr = (ImS8)ImClamp(v32, (int)IM_S8_MIN, (int)IM_S8_MAX);
|
|
|
+ else if (data_type == ImGuiDataType_U8)
|
|
|
+ *(ImU8*)data_ptr = (ImU8)ImClamp(v32, (int)IM_U8_MIN, (int)IM_U8_MAX);
|
|
|
+ else if (data_type == ImGuiDataType_S16)
|
|
|
+ *(ImS16*)data_ptr = (ImS16)ImClamp(v32, (int)IM_S16_MIN, (int)IM_S16_MAX);
|
|
|
+ else if (data_type == ImGuiDataType_U16)
|
|
|
+ *(ImU16*)data_ptr = (ImU16)ImClamp(v32, (int)IM_U16_MIN, (int)IM_U16_MAX);
|
|
|
+ else
|
|
|
+ IM_ASSERT(0);
|
|
|
+ }
|
|
|
+
|
|
|
return memcmp(data_backup, data_ptr, GDataTypeInfo[data_type].Size) != 0;
|
|
|
}
|
|
|
|
|
|
@@ -1876,6 +1930,10 @@ bool ImGui::DragBehavior(ImGuiID id, ImGuiDataType data_type, void* v, float v_s
|
|
|
|
|
|
switch (data_type)
|
|
|
{
|
|
|
+ case ImGuiDataType_S8: { ImS32 v32 = (ImS32)*(ImS8*)v; bool r = DragBehaviorT<ImS32, ImS32, float >(ImGuiDataType_S32, &v32, v_speed, v_min ? *(const ImS8*) v_min : IM_S8_MIN, v_max ? *(const ImS8*)v_max : IM_S8_MAX, format, power, flags); if (r) *(ImS8*)v = (ImS8)v32; return r; }
|
|
|
+ case ImGuiDataType_U8: { ImU32 v32 = (ImU32)*(ImU8*)v; bool r = DragBehaviorT<ImU32, ImS32, float >(ImGuiDataType_U32, &v32, v_speed, v_min ? *(const ImU8*) v_min : IM_U8_MIN, v_max ? *(const ImU8*)v_max : IM_U8_MAX, format, power, flags); if (r) *(ImU8*)v = (ImU8)v32; return r; }
|
|
|
+ case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)v; bool r = DragBehaviorT<ImS32, ImS32, float >(ImGuiDataType_S32, &v32, v_speed, v_min ? *(const ImS16*)v_min : IM_S16_MIN, v_max ? *(const ImS16*)v_max : IM_S16_MAX, format, power, flags); if (r) *(ImS16*)v = (ImS16)v32; return r; }
|
|
|
+ case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)v; bool r = DragBehaviorT<ImU32, ImS32, float >(ImGuiDataType_U32, &v32, v_speed, v_min ? *(const ImU16*)v_min : IM_U16_MIN, v_max ? *(const ImU16*)v_max : IM_U16_MAX, format, power, flags); if (r) *(ImU16*)v = (ImU16)v32; return r; }
|
|
|
case ImGuiDataType_S32: return DragBehaviorT<ImS32, ImS32, float >(data_type, (ImS32*)v, v_speed, v_min ? *(const ImS32* )v_min : IM_S32_MIN, v_max ? *(const ImS32* )v_max : IM_S32_MAX, format, power, flags);
|
|
|
case ImGuiDataType_U32: return DragBehaviorT<ImU32, ImS32, float >(data_type, (ImU32*)v, v_speed, v_min ? *(const ImU32* )v_min : IM_U32_MIN, v_max ? *(const ImU32* )v_max : IM_U32_MAX, format, power, flags);
|
|
|
case ImGuiDataType_S64: return DragBehaviorT<ImS64, ImS64, double>(data_type, (ImS64*)v, v_speed, v_min ? *(const ImS64* )v_min : IM_S64_MIN, v_max ? *(const ImS64* )v_max : IM_S64_MAX, format, power, flags);
|
|
|
@@ -2300,6 +2358,10 @@ bool ImGui::SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type
|
|
|
{
|
|
|
switch (data_type)
|
|
|
{
|
|
|
+ case ImGuiDataType_S8: { ImS32 v32 = (ImS32)*(ImS8*)v; bool r = SliderBehaviorT<ImS32, ImS32, float >(bb, id, ImGuiDataType_S32, &v32, *(const ImS8*)v_min, *(const ImS8*)v_max, format, power, flags, out_grab_bb); if (r) *(ImS8*)v = (ImS8)v32; return r; }
|
|
|
+ case ImGuiDataType_U8: { ImU32 v32 = (ImU32)*(ImU8*)v; bool r = SliderBehaviorT<ImU32, ImS32, float >(bb, id, ImGuiDataType_U32, &v32, *(const ImU8*)v_min, *(const ImU8*)v_max, format, power, flags, out_grab_bb); if (r) *(ImU8*)v = (ImU8)v32; return r; }
|
|
|
+ case ImGuiDataType_S16: { ImS32 v32 = (ImS32)*(ImS16*)v; bool r = SliderBehaviorT<ImS32, ImS32, float >(bb, id, ImGuiDataType_S32, &v32, *(const ImS16*)v_min, *(const ImS16*)v_max, format, power, flags, out_grab_bb); if (r) *(ImS16*)v = (ImS16)v32; return r; }
|
|
|
+ case ImGuiDataType_U16: { ImU32 v32 = (ImU32)*(ImU16*)v; bool r = SliderBehaviorT<ImU32, ImS32, float >(bb, id, ImGuiDataType_U32, &v32, *(const ImU16*)v_min, *(const ImU16*)v_max, format, power, flags, out_grab_bb); if (r) *(ImU16*)v = (ImU16)v32; return r; }
|
|
|
case ImGuiDataType_S32:
|
|
|
IM_ASSERT(*(const ImS32*)v_min >= IM_S32_MIN/2 && *(const ImS32*)v_max <= IM_S32_MAX/2);
|
|
|
return SliderBehaviorT<ImS32, ImS32, float >(bb, id, data_type, (ImS32*)v, *(const ImS32*)v_min, *(const ImS32*)v_max, format, power, flags, out_grab_bb);
|
|
|
@@ -3315,7 +3377,7 @@ bool ImGui::InputTextEx(const char* label, char* buf, int buf_size, const ImVec2
|
|
|
ClearActiveID();
|
|
|
|
|
|
// Release focus when we click outside
|
|
|
- if (g.ActiveId == id && io.MouseClicked[0] && !init_state && !init_make_active)
|
|
|
+ if (g.ActiveId == id && io.MouseClicked[0] && !init_state && !init_make_active) //-V560
|
|
|
clear_active_id = true;
|
|
|
|
|
|
bool value_changed = false;
|
|
|
@@ -3326,8 +3388,8 @@ bool ImGui::InputTextEx(const char* label, char* buf, int buf_size, const ImVec2
|
|
|
// FIXME-OPT: Because our selection/cursor code currently needs the wide text we need to convert it when active, which is not ideal :(
|
|
|
if (is_readonly && state != NULL)
|
|
|
{
|
|
|
- const bool will_render_cursor = (g.ActiveId == id) || (state && user_scroll_active);
|
|
|
- const bool will_render_selection = state && state->HasSelection() && (RENDER_SELECTION_WHEN_INACTIVE || will_render_cursor);
|
|
|
+ const bool will_render_cursor = (g.ActiveId == id) || (user_scroll_active);
|
|
|
+ const bool will_render_selection = state->HasSelection() && (RENDER_SELECTION_WHEN_INACTIVE || will_render_cursor);
|
|
|
if (will_render_cursor || will_render_selection)
|
|
|
{
|
|
|
const char* buf_end = NULL;
|
|
|
@@ -3932,20 +3994,20 @@ bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flag
|
|
|
// If we're not showing any slider there's no point in doing any HSV conversions
|
|
|
const ImGuiColorEditFlags flags_untouched = flags;
|
|
|
if (flags & ImGuiColorEditFlags_NoInputs)
|
|
|
- flags = (flags & (~ImGuiColorEditFlags__InputsMask)) | ImGuiColorEditFlags_RGB | ImGuiColorEditFlags_NoOptions;
|
|
|
+ flags = (flags & (~ImGuiColorEditFlags__DisplayMask)) | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_NoOptions;
|
|
|
|
|
|
// Context menu: display and modify options (before defaults are applied)
|
|
|
if (!(flags & ImGuiColorEditFlags_NoOptions))
|
|
|
ColorEditOptionsPopup(col, flags);
|
|
|
|
|
|
// Read stored options
|
|
|
- if (!(flags & ImGuiColorEditFlags__InputsMask))
|
|
|
- flags |= (g.ColorEditOptions & ImGuiColorEditFlags__InputsMask);
|
|
|
+ if (!(flags & ImGuiColorEditFlags__DisplayMask))
|
|
|
+ flags |= (g.ColorEditOptions & ImGuiColorEditFlags__DisplayMask);
|
|
|
if (!(flags & ImGuiColorEditFlags__DataTypeMask))
|
|
|
flags |= (g.ColorEditOptions & ImGuiColorEditFlags__DataTypeMask);
|
|
|
if (!(flags & ImGuiColorEditFlags__PickerMask))
|
|
|
flags |= (g.ColorEditOptions & ImGuiColorEditFlags__PickerMask);
|
|
|
- flags |= (g.ColorEditOptions & ~(ImGuiColorEditFlags__InputsMask | ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags__PickerMask));
|
|
|
+ flags |= (g.ColorEditOptions & ~(ImGuiColorEditFlags__DisplayMask | ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags__PickerMask));
|
|
|
|
|
|
const bool alpha = (flags & ImGuiColorEditFlags_NoAlpha) == 0;
|
|
|
const bool hdr = (flags & ImGuiColorEditFlags_HDR) != 0;
|
|
|
@@ -3953,14 +4015,14 @@ bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flag
|
|
|
|
|
|
// Convert to the formats we need
|
|
|
float f[4] = { col[0], col[1], col[2], alpha ? col[3] : 1.0f };
|
|
|
- if (flags & ImGuiColorEditFlags_HSV)
|
|
|
+ if (flags & ImGuiColorEditFlags_DisplayHSV)
|
|
|
ColorConvertRGBtoHSV(f[0], f[1], f[2], f[0], f[1], f[2]);
|
|
|
int i[4] = { IM_F32_TO_INT8_UNBOUND(f[0]), IM_F32_TO_INT8_UNBOUND(f[1]), IM_F32_TO_INT8_UNBOUND(f[2]), IM_F32_TO_INT8_UNBOUND(f[3]) };
|
|
|
|
|
|
bool value_changed = false;
|
|
|
bool value_changed_as_float = false;
|
|
|
|
|
|
- if ((flags & (ImGuiColorEditFlags_RGB | ImGuiColorEditFlags_HSV)) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)
|
|
|
+ if ((flags & (ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV)) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)
|
|
|
{
|
|
|
// RGB/HSV 0..255 Sliders
|
|
|
const float w_item_one = ImMax(1.0f, (float)(int)((w_items_all - (style.ItemInnerSpacing.x) * (components-1)) / (float)components));
|
|
|
@@ -3980,7 +4042,7 @@ bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flag
|
|
|
{ "R:%0.3f", "G:%0.3f", "B:%0.3f", "A:%0.3f" }, // Long display for RGBA
|
|
|
{ "H:%0.3f", "S:%0.3f", "V:%0.3f", "A:%0.3f" } // Long display for HSVA
|
|
|
};
|
|
|
- const int fmt_idx = hide_prefix ? 0 : (flags & ImGuiColorEditFlags_HSV) ? 2 : 1;
|
|
|
+ const int fmt_idx = hide_prefix ? 0 : (flags & ImGuiColorEditFlags_DisplayHSV) ? 2 : 1;
|
|
|
|
|
|
PushItemWidth(w_item_one);
|
|
|
for (int n = 0; n < components; n++)
|
|
|
@@ -4004,7 +4066,7 @@ bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flag
|
|
|
PopItemWidth();
|
|
|
PopItemWidth();
|
|
|
}
|
|
|
- else if ((flags & ImGuiColorEditFlags_HEX) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)
|
|
|
+ else if ((flags & ImGuiColorEditFlags_DisplayHex) != 0 && (flags & ImGuiColorEditFlags_NoInputs) == 0)
|
|
|
{
|
|
|
// RGB Hexadecimal Input
|
|
|
char buf[64];
|
|
|
@@ -4059,7 +4121,7 @@ bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flag
|
|
|
Spacing();
|
|
|
}
|
|
|
ImGuiColorEditFlags picker_flags_to_forward = ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags__PickerMask | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_AlphaBar;
|
|
|
- ImGuiColorEditFlags picker_flags = (flags_untouched & picker_flags_to_forward) | ImGuiColorEditFlags__InputsMask | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_AlphaPreviewHalf;
|
|
|
+ ImGuiColorEditFlags picker_flags = (flags_untouched & picker_flags_to_forward) | ImGuiColorEditFlags__DisplayMask | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_AlphaPreviewHalf;
|
|
|
PushItemWidth(square_sz * 12.0f); // Use 256 + bar sizes?
|
|
|
value_changed |= ColorPicker4("##picker", col, picker_flags, &g.ColorPickerRef.x);
|
|
|
PopItemWidth();
|
|
|
@@ -4079,7 +4141,7 @@ bool ImGui::ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flag
|
|
|
if (!value_changed_as_float)
|
|
|
for (int n = 0; n < 4; n++)
|
|
|
f[n] = i[n] / 255.0f;
|
|
|
- if (flags & ImGuiColorEditFlags_HSV)
|
|
|
+ if (flags & ImGuiColorEditFlags_DisplayHSV)
|
|
|
ColorConvertHSVtoRGB(f[0], f[1], f[2], f[0], f[1], f[2]);
|
|
|
if (value_changed)
|
|
|
{
|
|
|
@@ -4364,18 +4426,18 @@ bool ImGui::ColorPicker4(const char* label, float col[4], ImGuiColorEditFlags fl
|
|
|
PushItemWidth((alpha_bar ? bar1_pos_x : bar0_pos_x) + bars_width - picker_pos.x);
|
|
|
ImGuiColorEditFlags sub_flags_to_forward = ImGuiColorEditFlags__DataTypeMask | ImGuiColorEditFlags_HDR | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoOptions | ImGuiColorEditFlags_NoSmallPreview | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaPreviewHalf;
|
|
|
ImGuiColorEditFlags sub_flags = (flags & sub_flags_to_forward) | ImGuiColorEditFlags_NoPicker;
|
|
|
- if (flags & ImGuiColorEditFlags_RGB || (flags & ImGuiColorEditFlags__InputsMask) == 0)
|
|
|
- if (ColorEdit4("##rgb", col, sub_flags | ImGuiColorEditFlags_RGB))
|
|
|
+ if (flags & ImGuiColorEditFlags_DisplayRGB || (flags & ImGuiColorEditFlags__DisplayMask) == 0)
|
|
|
+ if (ColorEdit4("##rgb", col, sub_flags | ImGuiColorEditFlags_DisplayRGB))
|
|
|
{
|
|
|
// FIXME: Hackily differenciating using the DragInt (ActiveId != 0 && !ActiveIdAllowOverlap) vs. using the InputText or DropTarget.
|
|
|
// For the later we don't want to run the hue-wrap canceling code. If you are well versed in HSV picker please provide your input! (See #2050)
|
|
|
value_changed_fix_hue_wrap = (g.ActiveId != 0 && !g.ActiveIdAllowOverlap);
|
|
|
value_changed = true;
|
|
|
}
|
|
|
- if (flags & ImGuiColorEditFlags_HSV || (flags & ImGuiColorEditFlags__InputsMask) == 0)
|
|
|
- value_changed |= ColorEdit4("##hsv", col, sub_flags | ImGuiColorEditFlags_HSV);
|
|
|
- if (flags & ImGuiColorEditFlags_HEX || (flags & ImGuiColorEditFlags__InputsMask) == 0)
|
|
|
- value_changed |= ColorEdit4("##hex", col, sub_flags | ImGuiColorEditFlags_HEX);
|
|
|
+ if (flags & ImGuiColorEditFlags_DisplayHSV || (flags & ImGuiColorEditFlags__DisplayMask) == 0)
|
|
|
+ value_changed |= ColorEdit4("##hsv", col, sub_flags | ImGuiColorEditFlags_DisplayHSV);
|
|
|
+ if (flags & ImGuiColorEditFlags_DisplayHex || (flags & ImGuiColorEditFlags__DisplayMask) == 0)
|
|
|
+ value_changed |= ColorEdit4("##hex", col, sub_flags | ImGuiColorEditFlags_DisplayHex);
|
|
|
PopItemWidth();
|
|
|
}
|
|
|
|
|
|
@@ -4570,16 +4632,17 @@ bool ImGui::ColorButton(const char* desc_id, const ImVec4& col, ImGuiColorEditFl
|
|
|
return pressed;
|
|
|
}
|
|
|
|
|
|
+// Initialize/override default color options
|
|
|
void ImGui::SetColorEditOptions(ImGuiColorEditFlags flags)
|
|
|
{
|
|
|
ImGuiContext& g = *GImGui;
|
|
|
- if ((flags & ImGuiColorEditFlags__InputsMask) == 0)
|
|
|
- flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__InputsMask;
|
|
|
+ if ((flags & ImGuiColorEditFlags__DisplayMask) == 0)
|
|
|
+ flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DisplayMask;
|
|
|
if ((flags & ImGuiColorEditFlags__DataTypeMask) == 0)
|
|
|
flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DataTypeMask;
|
|
|
if ((flags & ImGuiColorEditFlags__PickerMask) == 0)
|
|
|
flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__PickerMask;
|
|
|
- IM_ASSERT(ImIsPowerOfTwo((int)(flags & ImGuiColorEditFlags__InputsMask))); // Check only 1 option is selected
|
|
|
+ IM_ASSERT(ImIsPowerOfTwo((int)(flags & ImGuiColorEditFlags__DisplayMask))); // Check only 1 option is selected
|
|
|
IM_ASSERT(ImIsPowerOfTwo((int)(flags & ImGuiColorEditFlags__DataTypeMask))); // Check only 1 option is selected
|
|
|
IM_ASSERT(ImIsPowerOfTwo((int)(flags & ImGuiColorEditFlags__PickerMask))); // Check only 1 option is selected
|
|
|
g.ColorEditOptions = flags;
|
|
|
@@ -4612,7 +4675,7 @@ void ImGui::ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags
|
|
|
|
|
|
void ImGui::ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags)
|
|
|
{
|
|
|
- bool allow_opt_inputs = !(flags & ImGuiColorEditFlags__InputsMask);
|
|
|
+ bool allow_opt_inputs = !(flags & ImGuiColorEditFlags__DisplayMask);
|
|
|
bool allow_opt_datatype = !(flags & ImGuiColorEditFlags__DataTypeMask);
|
|
|
if ((!allow_opt_inputs && !allow_opt_datatype) || !BeginPopup("context"))
|
|
|
return;
|
|
|
@@ -4620,9 +4683,9 @@ void ImGui::ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags)
|
|
|
ImGuiColorEditFlags opts = g.ColorEditOptions;
|
|
|
if (allow_opt_inputs)
|
|
|
{
|
|
|
- if (RadioButton("RGB", (opts & ImGuiColorEditFlags_RGB) != 0)) opts = (opts & ~ImGuiColorEditFlags__InputsMask) | ImGuiColorEditFlags_RGB;
|
|
|
- if (RadioButton("HSV", (opts & ImGuiColorEditFlags_HSV) != 0)) opts = (opts & ~ImGuiColorEditFlags__InputsMask) | ImGuiColorEditFlags_HSV;
|
|
|
- if (RadioButton("HEX", (opts & ImGuiColorEditFlags_HEX) != 0)) opts = (opts & ~ImGuiColorEditFlags__InputsMask) | ImGuiColorEditFlags_HEX;
|
|
|
+ if (RadioButton("RGB", (opts & ImGuiColorEditFlags_DisplayRGB) != 0)) opts = (opts & ~ImGuiColorEditFlags__DisplayMask) | ImGuiColorEditFlags_DisplayRGB;
|
|
|
+ if (RadioButton("HSV", (opts & ImGuiColorEditFlags_DisplayHSV) != 0)) opts = (opts & ~ImGuiColorEditFlags__DisplayMask) | ImGuiColorEditFlags_DisplayHSV;
|
|
|
+ if (RadioButton("Hex", (opts & ImGuiColorEditFlags_DisplayHex) != 0)) opts = (opts & ~ImGuiColorEditFlags__DisplayMask) | ImGuiColorEditFlags_DisplayHex;
|
|
|
}
|
|
|
if (allow_opt_datatype)
|
|
|
{
|
|
|
@@ -5377,7 +5440,8 @@ void ImGui::PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_ge
|
|
|
|
|
|
RenderFrame(frame_bb.Min, frame_bb.Max, GetColorU32(ImGuiCol_FrameBg), true, style.FrameRounding);
|
|
|
|
|
|
- if (values_count > 0)
|
|
|
+ const int values_count_min = (plot_type == ImGuiPlotType_Lines) ? 2 : 1;
|
|
|
+ if (values_count >= values_count_min)
|
|
|
{
|
|
|
int res_w = ImMin((int)frame_size.x, values_count) + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
|
|
|
int item_count = values_count + ((plot_type == ImGuiPlotType_Lines) ? -1 : 0);
|
omar