path: root/my_imgui_widgets.cpp

#include "imgui/imgui.h"
#include "imgui_ops.h"

// 0 for timeline keyframe, 1 for graph keyframe, 2 for left graph handle, 3 for right graph handle
internal void
ImGui_KeyframeDragging(project_data *File, project_state *State, ui *UI, property_channel *Property, int32 b, ImGuiIO io, int16 Type)
{
    keyframe *Keyframe = KeyframeLookupMemory(Property, b);
    if (ImGui::IsItemActive()) {

        if (!Keyframe->IsSelected && ImGui::IsItemActivated())
        {
            if (!io.KeyShift) {
                temp_keyframe_list Bad = GetSelectedKeyframes(File);
                for (int i = 0; i < Bad.Amount; i++)
                    Bad.SelectedKeyframe[i]->IsSelected = false;
            }
            Keyframe->IsSelected = true;
            State->RecentSelectionType = selection_keyframe;
        }
        if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1))
        {
            ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
            if (Type == 0 || Type == 1)
            {
                UI->DraggingKeyframeThreshold += io.MouseDelta.x;
                if (abs(UI->DraggingKeyframeThreshold) >= UI->TimelineZoom) {
                    int16 Increment = UI->DraggingKeyframeThreshold/UI->TimelineZoom;
                    // temp_keyframe_list Bad = GetSelectedKeyframes(File);
                    // for (int b = 0; b < Bad.Amount; b++) {
                    //     keyframe *SelectedKeyframe = Bad.SelectedKeyframe[b];
                        if (!(Keyframe->FrameNumber == 0 && Increment == -1)) {
                            Keyframe->FrameNumber += Increment;
                            CheckKeyframeSort(Property, Increment, b);
                            // SortAndCacheKeyframeAtFrame(SelectedKeyframe->FrameNumber, &File.LayerPTR[i]->Property[a], &Cache);
                            ClampSurroundingKeyframeHandles(Property, b);
                        }
                    // }
                    UI->DraggingKeyframeThreshold += -1*Increment*UI->TimelineZoom;
                    State->UpdateFrame = true;
                    State->UpdateKeyframes = true;
                    // Cache.Frame[File.CurrentFrame].Cached = false;
                }
            }
            if (Type != 0)
            {
                    if (Type == 1)
                    {
                        real32 IncrementsPerPixel = (Property->LocalMaxVal.f - Property->LocalMinVal.f)/Property->GraphLength;
                        Keyframe->Value.f -= io.MouseDelta.y*IncrementsPerPixel;
                        CalculatePropertyMinMax(Property);
                    }
                    if (Type == 2)
                    {
                        Keyframe->TangentLeft.x += io.MouseDelta.x/UI->TimelineZoom;
                        Keyframe->TangentLeft.y -= io.MouseDelta.y;
                        ClampKeyframeHandles(Property, b, 0);
                    }
                    if (Type == 3)
                    {
                        Keyframe->TangentRight.x += io.MouseDelta.x/UI->TimelineZoom;
                        Keyframe->TangentRight.y -= io.MouseDelta.y;
                        ClampKeyframeHandles(Property, b, 1);
                    }
                    State->UpdateFrame = true;
                    State->UpdateKeyframes = true;
            }
        }
    }
}

internal void
ImGui_PropertiesPanel(project_data *File, project_state *State, ui *UI, memory *Memory)
{
    if (State->MostRecentlySelectedLayer > -1) {
        project_layer *Layer = File->Layer[State->MostRecentlySelectedLayer];
        char buf[256];
        sprintf(buf, "Properties: %s###Properties", Layer->Name);
        ImGui::Begin(buf);
        if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
            UI->FocusedWindow = focus_properties;
        ImGui::Text("Transform");
        for (int h = 0; h < AmountOf(Layer->Property); h++) {
            property_channel *Property = &Layer->Property[h];
            ImGui::PushID(Property);
            if (ImGui::Button("K"))
                ManualKeyframeInsertF(Property, Memory, File->CurrentFrame, Property->CurrentValue.f);
            ImGui::SameLine();
            if (ImGui::DragScalar(Property->Name, ImGuiDataType_Float, &Property->CurrentValue.f,
                                  Property->ScrubVal.f, &Property->MinVal.f, &Property->MaxVal.f, "%f"))
            {
                State->UpdateFrame = true;
            }
            ImGui::PopID();
        }
        for (int h = 0; h < Layer->NumberOfEffects; h++) {
            effect *Effect = Layer->Effect[h];
            ImGui::Button("V"); ImGui::SameLine();
            ImGui::Text(Effect->Name);
            for (int i = 0; i < Effect->NumberOfProperties; i++) {
                property_channel *Property = &Effect->Property[i];
                ImGui::PushID(Property);
                if (Property->VarType == type_real)
                    ImGui::DragScalar(Property->Name, ImGuiDataType_Float, &Property->CurrentValue.f, 0.005f, &Property->MaxVal.f, &Property->MaxVal.f, "%f");
                if (Property->VarType == type_color)
                    if (ImGui::ColorEdit4("color 1", &Property->CurrentValue.f, ImGuiColorEditFlags_Float))
                        State->UpdateFrame = true;
                if (Property->VarType == type_blendmode)
                {
                    uint32 *item_current_idx = (uint32 *)&Property->CurrentValue.blendmode; // Here we store our selection data as an index.
                    if (ImGui::BeginListBox("Blend mode"))
                    {
                        for (int n = 0; n < IM_ARRAYSIZE(BlendmodeNames); n++)
                        {
                            const bool is_selected = (*item_current_idx == n);
                            if (ImGui::Selectable(BlendmodeNames[n], is_selected)) {
                                *item_current_idx = n;
                                State->UpdateFrame = true;
                            }

                            // Set the initial focus when opening the combo (scrolling + keyboard navigation focus)
                            if (is_selected)
                                ImGui::SetItemDefaultFocus();
                        }
                        ImGui::EndListBox();
                    }
                }
                ImGui::PopID();
            }
        }
    } else {
        char buf[256];
        sprintf(buf, "Properties: empty###Properties");
        ImGui::Begin(buf);
        if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
            UI->FocusedWindow = focus_properties;
    }
    ImGui::End();
}

internal v2
CalculateAnchorPointUV(project_layer *Layer, pixel_buffer *Buffer);

internal void
ImGui_Viewport(project_data File, project_state *State, ui *UI, pixel_buffer CompBuffer,
               ImGuiIO io, GLuint textureID)
{
    ImGui::Begin("Viewport");

    if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
        UI->FocusedWindow = focus_viewport;

    // Primarily taken from the Custom Rendering section of the demo
    ImVec2 ViewportMin = ImGui::GetCursorScreenPos();
    ImVec2 ViewportScale = ImGui::GetContentRegionAvail();
    ViewportScale.y -= ImGui::GetFontSize();
    if (ViewportScale.x < 50.0f) ViewportScale.x = 50.0f;
    if (ViewportScale.y < 50.0f) ViewportScale.y = 50.0f;
    ImVec2 ViewportMax = ImVec2(ViewportMin.x + ViewportScale.x, ViewportMin.y + ViewportScale.y);

    if (UI->Initializing) {
        UI->CompZoom = ImVec2(CompBuffer.Width, CompBuffer.Height);
        UI->CompPos = ImVec2(ViewportMin.x + ((ViewportMax.x - ViewportMin.x)/2 - UI->CompZoom.x/2),
                            ViewportMin.y + ((ViewportMax.y - ViewportMin.y)/2 - UI->CompZoom.y/2));
    }

    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    draw_list->AddRectFilled(ViewportMin, ViewportMax, IM_COL32(50, 50, 50, 255));
    draw_list->AddRect(ViewportMin, ViewportMax, IM_COL32(255, 255, 255, 255));

    ImGui::InvisibleButton("canvas", ViewportScale, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
    bool32 IsHovered = ImGui::IsItemHovered();
    bool32 IsActive = ImGui::IsItemActive();
    bool32 IsActivated = ImGui::IsItemActivated();


    if (IsHovered && IsActivated && ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
        v2 LocalMousePos = (V2(io.MousePos) - V2(ViewportMin));
        v2 LocalCompPos = V2(UI->CompPos) - V2(ViewportMin);
        v2 MouseScreenUV = LocalMousePos - LocalCompPos;
        UI->TempZoomRatio = MouseScreenUV / V2(UI->CompZoom); // AKA actual normalized UV of comp
        if (!ImGui::IsKeyDown(ImGuiKey_Z)) {
            for (int i = File.NumberOfLayers - 1; i >= 0; i--) {
               if (!io.KeyShift) DeselectAllLayers(&File, State);
               if (TestPointInLayer(File.Layer[i], &CompBuffer, UI->TempZoomRatio) && !File.Layer[i]->IsSelected)
               {
                   SelectLayer(File.Layer[i], State, i);
                   break;
               }
            }
        }
    }

    if (IsActive && ImGui::IsMouseDragging(ImGuiMouseButton_Right, -1.0f))
    {
        UI->CompPos.x += io.MouseDelta.x;
        UI->CompPos.y += io.MouseDelta.y;
    }
    // if (IsActive && ImGui::IsMouseDown(ImGuiMouseButton_Right))
    // {
    //     Debug.ToggleRenders = true;
    // }
    ImGui::OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonMiddle);
    if (ImGui::BeginPopup("context")) {
        if (ImGui::MenuItem("Scalar", NULL, false, InstructionMode != scalar_only)) { InstructionMode = scalar_only; State->UpdateFrame = true; }
        if (ImGui::MenuItem("SSE", NULL, false, InstructionMode != sse_enabled)) { InstructionMode = sse_enabled; State->UpdateFrame = true; }
        if (ImGui::MenuItem("AVX2", NULL, false, InstructionMode != avx_enabled)) { InstructionMode = avx_enabled; State->UpdateFrame = true; }
        ImGui::EndPopup();
    }
    if (IsActive && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1.0f) && ImGui::IsKeyDown(ImGuiKey_Z))
    {
        real32 Distance = io.MouseDelta.x + io.MouseDelta.y;
        UI->CompZoom.x += (Distance)*(real32)CompBuffer.Width/CompBuffer.Height;
        UI->CompZoom.y += (Distance);
        UI->CompPos.x -= ((Distance)*(real32)CompBuffer.Width/CompBuffer.Height)*UI->TempZoomRatio.x;
        UI->CompPos.y -= Distance*UI->TempZoomRatio.y;
    }

    draw_list->PushClipRect(ViewportMin, ViewportMax, true);
    draw_list->AddImage((void *)(intptr_t)textureID, ImVec2(UI->CompPos.x, UI->CompPos.y),
                           ImVec2(UI->CompPos.x + UI->CompZoom.x, UI->CompPos.y + UI->CompZoom.y));

    if (State->MostRecentlySelectedLayer > -1) {
        project_layer *Layer = File.Layer[State->MostRecentlySelectedLayer];
        ImVec2 AUV = ImVec2(Layer->x.CurrentValue.f / CompBuffer.Width, Layer->y.CurrentValue.f / CompBuffer.Height);
        ImVec2 ScreenAP = ImVec2(UI->CompPos.x + AUV.x * UI->CompZoom.x, UI->CompPos.y + AUV.y * UI->CompZoom.y);
        draw_list->AddNgon(ScreenAP, 20, ImGui::GetColorU32(ImGuiCol_ScrollbarGrab), 8, 10.0f);
    }

    draw_list->PopClipRect();

    ImGui::Text("%.1f", 100.0f * (UI->CompZoom.x / CompBuffer.Width));
    if (State->MsgTime > 0) {
        ImGui::SameLine();
        ImGui::SetCursorPosX((ViewportScale.x / 5)*4);
        ImGui::Text(State->Msg);
        State->MsgTime--;
    }

    ImGui::End();
}

// 1 for left, 2 for right, 3 for both
internal bool32
ImGui_SlidingLayer(project_layer *Layer, real32 *DraggingThreshold, real32 Delta, int16 TimelineZoom, int16 Side)
{
    bool32 Result = 0;
    if (ImGui::IsItemActive() && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1))
    {
        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
        *DraggingThreshold += Delta;
        if (abs(*DraggingThreshold) >= TimelineZoom) {
            int16 Increment = *DraggingThreshold/TimelineZoom;

            // TODO(fox): Properly handle the start and end points wrapping.

            if (!(Increment < 0 && Layer->StartFrame == 0 && Side & 1))
            {
                if (Side & 1)
                    Layer->StartFrame += Increment;
                if (Side & 2)
                    Layer->EndFrame += Increment;
                if (Side == 3) {
                    IncrementKeyframesInLayer(Layer, Increment);
                    if (Layer->SourceType == source_video) {
                        video_source *Source = (video_source *)Layer->RenderInfo;
                        Source->VideoFrameOffset += Increment;
                    }
                }
            }
            *DraggingThreshold += -1*Increment*TimelineZoom;
        }
        Result = 1;
    }
    return Result;
}

internal void
AddSource(project_data *File, memory *Memory, char * = NULL);

internal void
ImGui_File(project_data *File, project_state *State, memory *Memory, ui *UI, ImGuiIO io)
{
    ImGui::Begin("Files");
    ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
    if (ImGui::Button("Add source")) {
        AddSource(File, Memory);
    }
    if (State->DemoButton) {
        ImGui::SameLine();
        if (ImGui::Button("Generate demo scene")) {
            CreateDemoScene(File, Memory);
            State->UpdateKeyframes = true;
            State->UpdateFrame = true;
            State->DemoButton = false;
        }
    }
    if (State->GridButton) {
        ImGui::SameLine();
        if (ImGui::Button("Generate square grid")) {
            CreateGrid(File, Memory);
            State->UpdateKeyframes = true;
            State->UpdateFrame = true;
            State->GridButton = false;
        }
    }
    for (int16 i = 0; i < File->NumberOfSources; i++) {
        ImGui::PushID(i);
        ImGui::InputText("##source", File->Source[i], STRING_SIZE);
        ImGui::SameLine();
        if (ImGui::Button("Create Layer")) {
            CreateLayerFromSource(File, State, Memory, File->Source[i]);
        }
        ImGui::PopID();
    }
#if DEBUG
    for (int i = 0; i < Debug.WatchedProperties; i++) {
        if (Debug.DebugPropertyType[i] == d_float) {
            ImGui::Text("%s: %f", Debug.String[i], Debug.Val[i].f);
        } else if (Debug.DebugPropertyType[i] == d_int) {
            ImGui::Text("%s: %i", Debug.String[i], Debug.Val[i].i);
        } else if (Debug.DebugPropertyType[i] == d_uint) {
            ImGui::Text("%s: %u", Debug.String[i], Debug.Val[i].u);
        }
    }
#endif
    ImGui::End();
}

internal void
ImGui_EffectsPanel(project_data *File, project_state *State, memory *Memory, ui *UI, ImGuiIO io)
{
    ImGui::Begin("Effects list", NULL);
    if (State->RerouteEffects) {
        ImGui::SetKeyboardFocusHere();
        State->RerouteEffects = 0;
    }
    int value_changed = ImGui::InputText("Effect name...", State->filter.InputBuf, IM_ARRAYSIZE(State->filter.InputBuf),
                                          ImGuiInputTextFlags_CallbackCompletion, EffectConsoleCallback);

    if (Hacko) {
        if (!io.KeyShift)
            EffectSel++;
        else
            EffectSel--;
        Hacko = 0;
    }
    if (value_changed) {
        State->filter.Build();
        EffectSel = -1;
    }
    for (int32 i = 0; i < AmountOf(EffectList); i++) {
        if (State->filter.PassFilter(EffectList[i].Name)) {
            if (EffectSel == i) {
                bool t = true;
                ImGui::Selectable(EffectList[i].Name, &t);
            } else {
                bool s = false;
                ImGui::Selectable(EffectList[i].Name, &s);
            }
            // ImGui::Text(EffectList[i].Name);
        }
    }
    ImGui::End();
}


internal void
ImGui_Timeline(project_data *File, project_state *State, memory *Memory, ui *UI, ImGuiIO io)
{
    ImVec2 FramePadding = ImGui::GetStyle().FramePadding;
    ImVec2 ItemSpacing = ImGui::GetStyle().ItemSpacing;
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));       // makes setting up the layout easier
    ImGui::Begin("Timeline", NULL);

    if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
        UI->FocusedWindow = focus_timeline;

    real32 FontHeight = ImGui::GetFontSize();

    ImVec2 WindowSize = ImGui::GetWindowSize();
    if (WindowSize.x < 50.0f) WindowSize.x = 50.0f;     // prevent crashing if the window gets too small
    if (WindowSize.y < 50.0f) WindowSize.y = 50.0f;     // (still crashes)

    ImVec2 WindowMinAbs = ImGui::GetWindowPos();
    ImVec2 WindowMaxAbs = WindowMinAbs + WindowSize;

    ImVec2 ButtonSize = ImVec2(FontHeight*2, FontHeight*2);

    real32 TopbarHeight = FontHeight*4;
    ImVec2 TopbarMax = ImVec2(WindowMaxAbs.x, WindowMinAbs.y + TopbarHeight);

    ImVec2 TimelineBorderPadding = ImVec2(FontHeight, FontHeight);

    ImVec2 TopbarSize = ImVec2(WindowSize.x, TopbarHeight);
    ImVec2 TopbarButtonSize = ImVec2(TopbarHeight, TopbarHeight);

    // NOTE(fox): StartingPos values include X and Y scroll, primarily used for
    // the keyframes/layers. Absolute doesn't include scroll, primarily used
    // for the clip rects.

    ImVec2 SidebarSize = ImVec2(UI->TimelineSplit, WindowSize.y - TopbarHeight);
    ImVec2 SidebarSizeWithBorder = SidebarSize - TimelineBorderPadding*2;
    ImVec2 SidebarAbsolutePos = WindowMinAbs + ImVec2(0, TopbarSize.y) + TimelineBorderPadding;
    ImVec2 SidebarStartingPos = SidebarAbsolutePos + ImVec2(0, UI->ScrollYOffset);

    ImVec2 TimelineSize = ImVec2(WindowSize.x - SidebarSize.x, SidebarSize.y);
    ImVec2 TimelineSizeWithBorder = TimelineSize - TimelineBorderPadding*2;
    ImVec2 TimelineAbsolutePos = WindowMinAbs + ImVec2(SidebarSize.x, TopbarSize.y) + TimelineBorderPadding;
    ImVec2 TimelineStartingPos = SidebarStartingPos + ImVec2(SidebarSize.x + UI->ScrollXOffset, 0);

    // Timeline and sidebar size including the padding between them
    ImVec2 TimelineFullSize = TimelineSizeWithBorder + SidebarSizeWithBorder + ImVec2(TimelineBorderPadding.x*2, 0);

    ImVec2 KeyframeSize = ImVec2(FontHeight, FontHeight);

    ImVec2 PlayheadPos = ImVec2(TimelineStartingPos.x + UI->TimelineZoom * File->CurrentFrame, WindowMinAbs.y + TopbarSize.y/2);

    // NOTE(fox): The InvisibleButton hitbox that handles mouse inputs on the
    // graph occludes the hitbox that handles box drag selection, so I'm using
    // this struct to carry over the state from the former to the latter.
    imgui_buttonstate AnimationCurves = {};


    if (UI->Initializing) {
        UI->TimelineZoom = TimelineSizeWithBorder.x / (File->NumberOfFrames + 1);
    }

    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    draw_list->AddRectFilled(WindowMinAbs, WindowMaxAbs,
                             IM_COL32(255, 255, 255, 50));
    draw_list->AddRectFilled(WindowMinAbs, TopbarMax,
                             IM_COL32(255, 255, 255, 50));


    //


    ImGui::BeginChild("Topbar", TopbarSize, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar);
    ImGui::Button("V", TopbarButtonSize); ImGui::SameLine();
    ImGui::Button("V", TopbarButtonSize); ImGui::SameLine();
    ImGui::Button("V", TopbarButtonSize); ImGui::SameLine();

    ImGui::SetCursorScreenPos(PlayheadPos);
    ImGui::Button("P", ButtonSize);
    if (ImGui::IsItemActive()) {
        if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1))
        {
            UI->DraggingKeyframeThreshold += io.MouseDelta.x;
            if (abs(UI->DraggingKeyframeThreshold) >= UI->TimelineZoom) {
                int16 Increment = UI->DraggingKeyframeThreshold/UI->TimelineZoom;
                if (File->CurrentFrame <= 0 && Increment < File->StartFrame)
                    File->CurrentFrame = 0;
                else if (File->CurrentFrame >= File->EndFrame && Increment > File->EndFrame) {
                    File->CurrentFrame = File->EndFrame;
                } else {
                    File->CurrentFrame += Increment;
                }
                State->UpdateFrame = true;
                State->UpdateKeyframes = true;
                UI->DraggingKeyframeThreshold += -1*Increment*UI->TimelineZoom;
            }
        }
    }

    ImGui::EndChild();

    ///

    ImGui::BeginChild("Sidebar",  SidebarSize, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar);

    ImGui::SetCursorScreenPos(SidebarStartingPos);

    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ItemSpacing);

    ImGui::PushClipRect(SidebarAbsolutePos, SidebarAbsolutePos + SidebarSizeWithBorder, true);

    for (int i = File->NumberOfLayers - 1; i >= 0; i--)
    {
        project_layer *Layer = File->Layer[i];
        ImGui::PushID(i);

        ImGui::SetCursorScreenPos(ImVec2(SidebarStartingPos.x, ImGui::GetCursorScreenPos().y));

        draw_list->PushClipRect(SidebarAbsolutePos, SidebarAbsolutePos + TimelineFullSize, true);
        if (Layer->IsSelected) {
            real32 Y = ImGui::GetCursorScreenPos().y;
            draw_list->AddRectFilled(ImVec2(SidebarAbsolutePos.x, Y),
                                     ImVec2(TimelineAbsolutePos.x + TimelineSize.x, Y + FontHeight + FramePadding.y*2),
                                     IM_COL32(255, 255, 255, 50));
        }
        draw_list->PopClipRect();

        ImGui::Button("V"); ImGui::SameLine();
        ImGui::Button("I"); ImGui::SameLine();
        ImGui::Text(Layer->Name); ImGui::SameLine();
        ImGui::Button(BlendmodeNames[Layer->BlendMode]);
        ImGui::OpenPopupOnItemClick("blendmode_picker", ImGuiPopupFlags_MouseButtonLeft);
        if (ImGui::BeginPopup("blendmode_picker")) {
            for (int16 b = 0; b < AmountOf(BlendmodeNames); b++) {
                if (ImGui::MenuItem(BlendmodeNames[b], NULL, false, Layer->BlendMode != b)) {
                    Layer->BlendMode = (blend_mode)b;
                    State->UpdateFrame = true;
                }
                // using IsActivated here instead of above loop doesn't seem to
                // work; the popup gets closed instead
                if (ImGui::IsItemHovered() && io.KeyCtrl) {
                    Layer->BlendMode = (blend_mode)b;
                    State->UpdateFrame = true;
                }
            }
            ImGui::EndPopup();
        }
        ImGui::SameLine();

        ImGui::SetCursorScreenPos(ImVec2(SidebarStartingPos.x, ImGui::GetCursorScreenPos().y));
        ImGui::Button("##mover", ImVec2(SidebarSizeWithBorder.x, FontHeight + FramePadding.y*2));

        // Layer dragging interaction

        if (ImGui::IsItemActive()) {
            if (ImGui::IsItemActivated() && !Layer->IsSelected)
            {
                if (!io.KeyShift) DeselectAllLayers(File, State);
                SelectLayer(Layer, State, i);
            }
            if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1) )
            {
                ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
                UI->DraggingLayerThreshold -= io.MouseDelta.y;
                real32 Threshold = FontHeight + FramePadding.y*2;
                if (abs(UI->DraggingLayerThreshold) >= Threshold)
                {
                    int16 Increment = UI->DraggingLayerThreshold/abs(UI->DraggingLayerThreshold);
                    MoveLayersByIncrement(File, State, Increment);
                    UI->DraggingLayerThreshold += -1*Increment*Threshold;
                    State->UpdateFrame = true;
                    // Cache.Frame[File->CurrentFrame].Cached = false;
                }
            }
        }

        // Properties gap

        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, ItemSpacing.y * UI->KeyframeSpacing));
        for (int a = 0; a < AmountOf(Layer->Property); a++) {
            if (Layer->Property[a].IsToggled)
            {
                property_channel *Property = &Layer->Property[a];
                ImGui::PushID(Property);
                // if (Property->IsSelected) {
                //     real32 Y = ImGui::GetCursorScreenPos().y;
                //     draw_list->AddRectFilled(ImVec2(SidebarAbsolutePos.x, Y),
                //                              ImVec2(TimelineAbsolutePos.x, Y + FontHeight + FramePadding.y*2),
                //                              IM_COL32(100, 0, 255, 50));
                // }
                ImGui::SetCursorScreenPos(ImVec2(SidebarStartingPos.x, ImGui::GetCursorScreenPos().y));
                ImGui::Text(Property->Name);
                real32 YInit = ImGui::GetCursorScreenPos().y;
                ImGui::SameLine();
                if (ImGui::Button("K"))
                    ManualKeyframeInsertF(Property, Memory, File->CurrentFrame, Property->CurrentValue.f);
                ImGui::SameLine();
                if (ImGui::Button("G")) {
                    SwitchBool(Property->IsGraphToggled);
                    // TODO(fox): Make system to init things like these automatically?
                    if (!Property->GraphLength) {
                        Property->GraphLength = 150;
                        Property->GraphYOffset = (Property->GraphWindowHeight - Property->GraphLength)/2;
                    }
                }
                ImGui::SetCursorScreenPos(ImVec2(ImGui::GetCursorScreenPos().x, YInit));
                if (Property->IsGraphToggled)
                {
                    ImGui::Dummy(ImVec2(5, Property->GraphWindowHeight));
                }
                ImGui::PopID();
            }
        }
        ImGui::PopStyleVar();

        ImGui::PopID();
    }

    ImGui::PopClipRect();

    /// Split size adjuster

    ImGui::SetCursorScreenPos(ImVec2(WindowMinAbs.x + UI->TimelineSplit - TimelineBorderPadding.x, TimelineAbsolutePos.y));
    ImGui::InvisibleButton("##SplitMove", ImVec2(TimelineBorderPadding.x, SidebarSizeWithBorder.y), ImGuiButtonFlags_MouseButtonLeft);
    if (ImGui::IsItemHovered()) {
        ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
    }
    if (ImGui::IsItemActive() && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1))
    {
        UI->TimelineSplit += io.MouseDelta.x;
    }


    ImGui::PopStyleVar();

    ImGui::EndChild();
    ImGui::SameLine();

    ///

    ImGui::BeginChild("Timeline",  TimelineSize, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar);

    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, ItemSpacing.y));

    ImGui::SetCursorScreenPos(TimelineStartingPos);

    ImGui::PushClipRect(TimelineAbsolutePos, TimelineAbsolutePos + TimelineSizeWithBorder, true);
    draw_list->PushClipRect(TimelineAbsolutePos, TimelineAbsolutePos + TimelineSizeWithBorder, true);

    for (int i = File->NumberOfLayers - 1; i >= 0; i--)
    {
        // The actual layer bars

        project_layer *Layer = File->Layer[i];
        ImGui::PushID(i);
        uint16 LayerTLSpan = Layer->EndFrame - Layer->StartFrame;

        // if (Layer->SourceType == video) {
        //     video_source *Source = (video_source *)Layer->RenderInfo;
        //     real32 XMin = TimelineMinX + UI->TimelineZoom*Source->VideoFrameOffset;
        //     // real32 YMin = StartingCursorPosAbs.y + (FontHeight + FramePadding.y*2 + ItemSpacing.y)*i;
        //     real32 YMin = ImGui::GetCursorScreenPos().y;
        //     draw_list->AddRect(ImVec2(WindowMin.x, YMin),
        //                        ImVec2(WindowMaxAbs.x, YMin + FontHeight + FramePadding.y*2),
        //                        IM_COL32(255, 255, 255, 50), 2);
        // }

        ImGui::SetCursorScreenPos(ImVec2(TimelineStartingPos.x + UI->TimelineZoom*Layer->StartFrame, ImGui::GetCursorScreenPos().y));
        ImGui::Button("##leftbound", ImVec2(0.5 * UI->TimelineZoom, 0)); ImGui::SameLine();
        if (ImGui::IsItemHovered()) {
            ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
        }
        ImGui_SlidingLayer(Layer, &UI->DraggingKeyframeThreshold, io.MouseDelta.x, UI->TimelineZoom, 1);

        // TODO(fox): Investigate why this button doesn't get lined up with
        // leftbound in certain cases. (i.e. rotation property expanded with keyframes)

        ImGui::Button("##layer", ImVec2((LayerTLSpan * UI->TimelineZoom), 0)); ImGui::SameLine();
        if (ImGui::IsItemClicked()) {
            if (!io.KeyShift) DeselectAllLayers(File, State);
            SelectLayer(Layer, State, i);
        }
        if (ImGui_SlidingLayer(Layer, &UI->DraggingLayerThreshold, io.MouseDelta.x, UI->TimelineZoom, 3)) {
            // TODO(fox): This will be removed once video caching is implemented.
            UI->TemporaryUpdateOverride = true;
        }

        ImGui::Button("##rightbound", ImVec2(0.5 * UI->TimelineZoom, 0));

        if (ImGui::IsItemHovered()) {
            ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
        }
        ImGui_SlidingLayer(Layer, &UI->DraggingKeyframeThreshold, io.MouseDelta.x, UI->TimelineZoom, 2);

        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, ItemSpacing.y * UI->KeyframeSpacing));
        ImGui::SetCursorPosY(ImGui::GetCursorPos().y + (ItemSpacing.y * UI->KeyframeSpacing / 2));

        for (int a = 0; a < AmountOf(Layer->Property); a++) {
            if (Layer->Property[a].IsToggled)
            {
                real32 InitialY = ImGui::GetCursorScreenPos().y;
                ImGui::NewLine();
                real32 NextY = ImGui::GetCursorScreenPos().y;

                property_channel *Property = &Layer->Property[a];
                ImGui::PushID(Property);

                for (int b = 0; b < Layer->Property[a].NumberOfTotalKeyframes; b++) {
                    keyframe *Keyframe = KeyframeLookupMemory(Property, b);
                    real32 KeyframeOrigin = TimelineStartingPos.x + UI->TimelineZoom*Keyframe->FrameNumber;
                    ImVec2 KeyframePosition = ImVec2(KeyframeOrigin - FontHeight/2, InitialY);

                    ImGui::PushID(Keyframe);

                    ImGui::SetCursorScreenPos(KeyframePosition);

                    // sadly ImGui::Selectable doesn't work here
                    if (Keyframe->IsSelected)
                        ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetColorU32(ImGuiCol_ButtonHovered));

                    ImGui::Button("##keyframe", ImVec2(FontHeight, FontHeight));
                    ImGui::SameLine();

                    if (Keyframe->IsSelected)
                        ImGui::PopStyleColor();

                    if (UI->BoxSelectActive && UI->BoxStart.y < NextY) {
                        if (IsRectTouching(UI->BoxStart, UI->BoxEnd, KeyframePosition, KeyframePosition + KeyframeSize)) {
                            SelectKeyframe(File, Layer, Property, Keyframe);
                            State->RecentSelectionType = selection_keyframe;
                        } else if (!io.KeyShift) {
                            Keyframe->IsSelected = false;
                        }
                    }

                    ImGui_KeyframeDragging(File, State, UI, Property, b, io, 0);


                    ImGui::PopID();
                }

                ImGui::SetCursorScreenPos(ImVec2(ImGui::GetCursorScreenPos().x, NextY));

                if (Property->IsGraphToggled)
                {
                    uint16 GraphWindowHeight = File->Layer[i]->Property[a].GraphWindowHeight;
                    real32 GraphWindowLocalYMin = ImGui::GetCursorPosY();
                    ImDrawList* draw_list = ImGui::GetWindowDrawList();
                    real32 ScreenY = NextY;
                    ImVec2 MinPos = ImVec2(TimelineAbsolutePos.x, ScreenY);
                    ImVec2 MaxPos = ImVec2(TimelineAbsolutePos.x + TimelineSizeWithBorder.x, ScreenY + GraphWindowHeight);
                    draw_list->AddRectFilled(MinPos, MaxPos,
                                             IM_COL32(00, 00, 30, 65));

                    draw_list->PushClipRect(MinPos, MaxPos, true);

                    ImVec2 LeftPos[2];
                    ImVec2 MidPos[2];
                    ImVec2 RightPos[2];
                    ImU32 col = ImGui::GetColorU32(ImGuiCol_ScrollbarGrab);

                    for (int b = 0; b < Property->NumberOfTotalKeyframes; b++) {
                        keyframe *Keyframe = KeyframeLookupMemory(Property, b);
                        // int32 Index = KeyframeMemoryToIndex(Property, b);

                        ImGui::PushID(Keyframe);

                        real32 MinVal = Property->LocalMinVal.f;
                        real32 MaxVal = Property->LocalMaxVal.f;

                        // Normalized ratio between the smallest and largest value
                        real32 HandleYRatio =   (Keyframe->Value.f - MaxVal) / (MaxVal - MinVal);
                        real32 HandleYRatio_L = (Keyframe->Value.f + Keyframe->TangentLeft.y - MaxVal) / (MaxVal - MinVal);
                        real32 HandleYRatio_R = (Keyframe->Value.f + Keyframe->TangentRight.y - MaxVal) / (MaxVal - MinVal);

                        real32 LocalHandlePosX = UI->TimelineZoom*Keyframe->FrameNumber;
                        real32 LocalHandlePosX_L = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentLeft.x;
                        real32 LocalHandlePosX_R = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentRight.x;

                        real32 HandlePosX   = TimelineStartingPos.x + LocalHandlePosX   - FontHeight*0.5;
                        real32 HandlePosX_L = TimelineStartingPos.x + LocalHandlePosX_L - FontHeight*0.5;
                        real32 HandlePosX_R = TimelineStartingPos.x + LocalHandlePosX_R - FontHeight*0.5;

                        real32 LocalHandlePosY   = HandleYRatio * Property->GraphLength;
                        real32 LocalHandlePosY_L = HandleYRatio_L * Property->GraphLength;
                        real32 LocalHandlePosY_R = HandleYRatio_R * Property->GraphLength;

                        real32 HandlePosY   = MinPos.y - LocalHandlePosY   + Property->GraphYOffset;
                        real32 HandlePosY_L = MinPos.y - LocalHandlePosY_L + Property->GraphYOffset;
                        real32 HandlePosY_R = MinPos.y - LocalHandlePosY_R + Property->GraphYOffset;

                        ImVec2 HandlePos   = ImVec2(HandlePosX,   HandlePosY);
                        ImVec2 HandlePos_L = ImVec2(HandlePosX_L, HandlePosY_L);
                        ImVec2 HandlePos_R = ImVec2(HandlePosX_R, HandlePosY_R);

                        if (UI->BoxSelectActive && UI->BoxStart.y >= NextY) {
                            if (IsRectTouching(UI->BoxStart, UI->BoxEnd, HandlePos, HandlePos + KeyframeSize)) {
                                Keyframe->IsSelected = true;
                                State->RecentSelectionType = selection_keyframe;
                            } else if (!io.KeyShift) {
                                Keyframe->IsSelected = false;
                            }
                        }

                        ImGui::PushStyleColor(ImGuiCol_Button, col);

                        ImGui::SetCursorScreenPos(ImVec2(HandlePosX - FontHeight*1.5, HandlePosY - FontHeight*1.5));
                        ImGui::Text("%.02f", Keyframe->Value.f);

                        ImGui::SetCursorScreenPos(ImVec2(HandlePosX - FontHeight*1.0, HandlePosY - FontHeight*1.0));
                        ImGui::InvisibleButton("##keyframepoint", ImVec2(FontHeight*2, FontHeight*2), ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);

                        draw_list->AddRect(ImVec2(HandlePosX - FontHeight*0.5, HandlePosY - FontHeight*0.5),
                                           ImVec2(HandlePosX + FontHeight*0.5, HandlePosY + FontHeight*0.5),
                                           ImGui::GetColorU32(ImGuiCol_ButtonHovered));

                        ImGui_KeyframeDragging(File, State, UI, Property, b, io, 1);

                        if (Keyframe->IsSelected && Keyframe->Type == bezier) {

                            ImGui::SetCursorScreenPos(ImVec2(HandlePosX_L, HandlePosY_L));
                            draw_list->AddCircle(ImVec2(HandlePosX_L, HandlePosY_L), 2, col, 16, 1);
                            ImGui::Button("##keyframehandleleft", ImVec2(FontHeight, FontHeight));

                            ImGui_KeyframeDragging(File, State, UI, Property, b, io, 2);

                            ImGui::SetCursorScreenPos(ImVec2(HandlePosX_R, HandlePosY_R));
                            ImGui::Button("##keyframehandleright", ImVec2(FontHeight, FontHeight));

                            ImGui_KeyframeDragging(File, State, UI, Property, b, io, 3);

                            draw_list->AddLine(MidPos[b & 1], RightPos[b & 1], col, 1.0f);
                            draw_list->AddLine(MidPos[b & 1], LeftPos[b & 1], col, 1.0f);
                        }

                        ImGui::PopStyleColor();

                        ImGui::PopID();
                    }

                    // TODO(fox): Reformat this so it's all done in one loop.

                    for (int b = 0; b < Property->NumberOfTotalKeyframes; b++) {
                        keyframe *Keyframe = KeyframeLookupIndex(Property, b);

                        real32 MinVal = Property->LocalMinVal.f;
                        real32 MaxVal = Property->LocalMaxVal.f;

                        real32 HandleYRatio =   (Keyframe->Value.f - MaxVal) / (MaxVal - MinVal);
                        real32 HandleYRatio_L = (Keyframe->Value.f + Keyframe->TangentLeft.y - MaxVal) / (MaxVal - MinVal);
                        real32 HandleYRatio_R = (Keyframe->Value.f + Keyframe->TangentRight.y - MaxVal) / (MaxVal - MinVal);

                        real32 LocalHandlePosX = UI->TimelineZoom*Keyframe->FrameNumber;
                        real32 LocalHandlePosX_L = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentLeft.x;
                        real32 LocalHandlePosX_R = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentRight.x;

                        real32 HandlePosX   = TimelineStartingPos.x + LocalHandlePosX   - FontHeight*0.5;
                        real32 HandlePosX_L = TimelineStartingPos.x + LocalHandlePosX_L - FontHeight*0.5;
                        real32 HandlePosX_R = TimelineStartingPos.x + LocalHandlePosX_R - FontHeight*0.5;

                        real32 LocalHandlePosY   = HandleYRatio * Property->GraphLength;
                        real32 LocalHandlePosY_L = HandleYRatio_L * Property->GraphLength;
                        real32 LocalHandlePosY_R = HandleYRatio_R * Property->GraphLength;

                        real32 HandlePosY   = MinPos.y - LocalHandlePosY   + Property->GraphYOffset;
                        real32 HandlePosY_L = MinPos.y - LocalHandlePosY_L + Property->GraphYOffset;
                        real32 HandlePosY_R = MinPos.y - LocalHandlePosY_R + Property->GraphYOffset;

                        ImVec2 HandlePos   = ImVec2(HandlePosX,   HandlePosY);
                        ImVec2 HandlePos_L = ImVec2(HandlePosX_L, HandlePosY_L);
                        ImVec2 HandlePos_R = ImVec2(HandlePosX_R, HandlePosY_R);

                        MidPos[b & 1] =   HandlePos;
                        LeftPos[b & 1] =  HandlePos_L;
                        RightPos[b & 1] = HandlePos_R;

                        if (b != 0)
                        {
                            if (b & 1) {
                                if (Keyframe->Type == linear)
                                    draw_list->AddLine(MidPos[0], MidPos[1], col, 1.0f);
                                else if (Keyframe->Type == bezier)
                                    draw_list->AddBezierCubic(MidPos[0], RightPos[0], LeftPos[1], MidPos[1], col, 1.0f, 8);
                            } else {
                                if (Keyframe->Type == linear)
                                    draw_list->AddLine(MidPos[1], MidPos[0], col, 1.0f);
                                else if (Keyframe->Type == bezier)
                                    draw_list->AddBezierCubic(MidPos[1], RightPos[1], LeftPos[0], MidPos[0], col, 1.0f, 8);
                            }
                        }
                    }
                    // Horiziontal value lines

                    // uint32 LineColor = IM_COL32(200, 200, 200, 40);
                    // for (int i = 0; i < 10; i++) {
                    //     real32 YPos = MinPos.y + (UI->TimelineZoom/2 * i) + 5;
                    //     ImVec2 Min = ImVec2(TimelineStartingPos.x, YPos);
                    //     ImVec2 Max = ImVec2(TimelineStartingPos.x + TimelineSize.x, YPos);
                    //     draw_list->AddLine(Min, Max, LineColor);
                    // }

                    draw_list->PopClipRect();

                    // ImGui::SetCursorScreenPos(ImVec2(MinPos.x, MinPos.y));
                    // ImGui::Button("##SplitMove", ImVec2(TimelineBorderPadding.x, SidebarSizeWithBorder.y));
                    // if (ImGui::IsItemActive() && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1))
                    // {
                    //     UI->TimelineSplit += io.MouseDelta.x;
                    // }

                    ImGui::SetCursorScreenPos(ImVec2(MinPos.x, MinPos.y));
                    ImGui::InvisibleButton("AnimationCurves", ImVec2(TimelineSize.x - 20, GraphWindowHeight), ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
                    // NOTE(fox): I'm reusing this struct for the other
                    // channels, so I'm OR'ing it. Also persists across layers.
                    AnimationCurves.IsItemHovered |= ImGui::IsItemHovered();
                    AnimationCurves.IsItemActive |= ImGui::IsItemActive();
                    AnimationCurves.IsItemActivated |= ImGui::IsItemActivated();
                    AnimationCurves.IsItemDeactivated |= ImGui::IsItemDeactivated();
                    AnimationCurves.LeftClick |= ImGui::IsMouseDown(ImGuiMouseButton_Left);
                    AnimationCurves.RightClick |= ImGui::IsMouseDown(ImGuiMouseButton_Right);

                    if (AnimationCurves.IsItemHovered && AnimationCurves.IsItemActivated &&
                        ImGui::IsMouseDown(ImGuiMouseButton_Right)) {
                        real32 LocalMousePos = io.MousePos.y - MinPos.y - Property->GraphYOffset;
                        UI->TempZoomRatioGraph = LocalMousePos / Property->GraphLength;
                    }
                    // DebugWatchVar("LocalMousePos", &LocalMousePos, d_float);

                    if (AnimationCurves.IsItemActive && ImGui::IsMouseDragging(ImGuiMouseButton_Right, -1))
                    {
                        Property->GraphLength += io.MouseDelta.x;
                        Property->GraphYOffset -= io.MouseDelta.x*UI->TempZoomRatioGraph;
                        Property->GraphYOffset += io.MouseDelta.y;
                    }
                }
                ImGui::PopID();
            }
        }

        ImGui::SetCursorPosY(ImGui::GetCursorPos().y - (ItemSpacing.y * UI->KeyframeSpacing / 2));
        ImGui::PopStyleVar();

        ImGui::PopID();
    }

    // Timeline frame ticks

    ImGui::SetCursorScreenPos(TimelineStartingPos);
    if (UI->TimelineZoom > 10) {
        for (float x = 0; x < File->NumberOfFrames + 2; x += 1) {
            uint32 LineColor = IM_COL32(200, 200, 200, 40);
            ImVec2 Min = ImVec2(TimelineStartingPos.x + UI->TimelineZoom * x, TimelineStartingPos.y);
            ImVec2 Max = ImVec2(Min.x + 2, WindowMaxAbs.y);
            if (x == File->CurrentFrame) continue;
            draw_list->AddLine(Min, Max, LineColor);
        }
    }



    draw_list->PopClipRect();
    ImGui::PopClipRect();

    // Playhead line

    uint32 LineColor = IM_COL32(200, 200, 200, 200);
    ImVec2 Min = PlayheadPos;
    ImVec2 Max = ImVec2(Min.x + 2, Min.y + TimelineSizeWithBorder.y + TopbarSize.y/2);
    draw_list->AddLine(Min, Max, LineColor);

    ImGui::PopStyleVar();

    // General timeline interaction

    ImGui::SetCursorScreenPos(TimelineAbsolutePos);
    ImGui::InvisibleButton("TimelineMoving", TimelineSizeWithBorder, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
    bool32 IsHovered = ImGui::IsItemHovered();
    bool32 IsActive = ImGui::IsItemActive();
    bool32 IsItemActivated = ImGui::IsItemActivated();
    bool32 IsItemDeactivated = ImGui::IsItemDeactivated();
    bool32 LeftClick = ImGui::IsMouseDown(ImGuiMouseButton_Left);
    bool32 RightClick = ImGui::IsMouseDown(ImGuiMouseButton_Right);

    if (IsActive || AnimationCurves.IsItemActive) {
        if (LeftClick) {
            if (io.KeyCtrl && IsActive) {
                real32 LocalMousePos = ImGui::GetMousePos().x - TimelineStartingPos.x;
                real32 ZoomRatio = LocalMousePos / UI->TimelineZoom;
                File->CurrentFrame = (int32)(ZoomRatio + 0.5);
                State->UpdateFrame = true;
                State->UpdateKeyframes = true;
            } else {
                if (IsItemActivated || AnimationCurves.IsItemActivated)
                {
                    if (!io.KeyShift) {
                        // DeselectAllKeyframes(&State);
                        // DeselectAllLayers(File, State);
                    }
                    UI->BoxStart = ImGui::GetMousePos();
                    UI->BoxSelectActive = true;
                }
                if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1) )
                {
                    UI->BoxEnd = ImGui::GetMousePos();
                    draw_list->AddRectFilled(UI->BoxStart, UI->BoxEnd,
                                             IM_COL32(0, 0, 200, 50));
                }
            }
        // Timeline zooming interaction
        } else if (RightClick && IsActive) {
            if (IsItemActivated)
            {
                real32 LocalMousePos = io.MousePos.x - WindowMinAbs.x - UI->TimelineSplit;
                UI->TempZoomRatioTimeline = LocalMousePos / TimelineSize.x;
            }
            if (ImGui::IsMouseDragging(ImGuiMouseButton_Right, -1) )
            {
                UI->TimelineZoom += io.MouseDelta.x;
                ImGui::SetScrollX(ImGui::GetScrollMaxX() * UI->TempZoomRatioTimeline);
            }
        }
    }
    if (IsItemDeactivated || AnimationCurves.IsItemDeactivated) {
        UI->BoxStart = {0, 0};
        UI->BoxEnd = {0, 0};
        UI->BoxSelectActive = false;
    }

    ImGui::EndChild();

    ImGui::PopStyleVar(2);

    if (IsRectTouching(WindowMinAbs, WindowMaxAbs, io.MousePos, io.MousePos + 1)) {
        if (io.KeyCtrl && io.MouseWheel) {
            real32 ZoomAmount = io.MouseWheel*16;
            real32 LocalMousePos = ImGui::GetMousePos().x - TimelineStartingPos.x;
            real32 ZoomRatio = LocalMousePos / UI->TimelineZoom;
            UI->TimelineZoom += ZoomAmount;
            UI->ScrollXOffset -= ZoomAmount*ZoomRatio;
        } else if (io.KeyShift && io.MouseWheel) {
            UI->ScrollXOffset += io.MouseWheel*16;
        } else {
            UI->ScrollXOffset += io.MouseWheelH*16;
            UI->ScrollYOffset += io.MouseWheel*16;
        }
    }



    ImGui::End();
}


internal void
ImGui_ProcessInputs(project_data *File, project_state *State, pixel_buffer *CompBuffer, memory *Memory, ui *UI, ImGuiIO io)
{
    if (io.KeysData[ImGuiKey_Q].Down)
        State->IsRunning = false;

    if (ImGui::IsKeyPressed(ImGuiKey_D)) {
        IncrementFrame(File, -1);
        State->UpdateFrame = true;
        State->UpdateKeyframes = true;
    }

    if (ImGui::IsKeyPressed(ImGuiKey_F)) {
        IncrementFrame(File, 1);
        State->UpdateFrame = true;
        State->UpdateKeyframes = true;
    }


    if (ImGui::IsKeyPressed(ImGuiKey_Space)) {
        if (io.KeyShift) {
            State->RerouteEffects = true;
        } else {
            SwitchBool(State->IsPlaying);
        }
    }


    if (State->IsPlaying && !IsRendering) {
        IncrementFrame(File, 1);
        State->UpdateFrame = true;
        State->UpdateKeyframes = true;
    }

    if (ImGui::IsKeyPressed(ImGuiKey_R) && State->NumberOfSelectedLayers)
        TransformsInteract(File, State, UI, sliding_rotation);
    if (ImGui::IsKeyPressed(ImGuiKey_S)  && State->NumberOfSelectedLayers)
        TransformsInteract(File, State, UI, sliding_scale);
    if (ImGui::IsKeyPressed(ImGuiKey_G)  && State->NumberOfSelectedLayers)
        TransformsInteract(File, State, UI, sliding_position);
    if (ImGui::IsKeyPressed(ImGuiKey_A)  && State->NumberOfSelectedLayers)
        TransformsInteract(File, State, UI, sliding_anchorpoint);

    if (ImGui::IsKeyPressed(ImGuiKey_1))
        LoadTestFootage(File, State, Memory);

    if (ImGui::IsKeyPressed(ImGuiKey_Delete))
    {
        switch (State->RecentSelectionType)
        {
            case selection_none:
            {
            } break;
            case selection_layer:
            {
            } break;
            case selection_effect:
            {
            } break;
            case selection_keyframe:
            {
                DeleteSelectedKeyframes(File, Memory);
                State->UpdateKeyframes = true;
                State->UpdateFrame = true;
            } break;
        }
    }

#if DEBUG
    if (ImGui::IsKeyPressed(ImGuiKey_W))
    {
        SwitchBool(Debug.ToggleWindow);
    }
    if (ImGui::IsKeyPressed(ImGuiKey_M))
    {
        Debug.Markers[Debug.MarkerIndex] = File->CurrentFrame;
        Debug.MarkerIndex++;
    }
#endif

    bool32 Ended = ImGui::IsMouseDown(ImGuiMouseButton_Left);
    if (State->IsInteracting) {
        ImVec2 MouseIncrement = io.MouseDelta * (ImVec2(CompBuffer->Width, CompBuffer->Height) / UI->CompZoom);
        switch (State->TransformsHotkeyInteract)
        {
            case sliding_position:
            {
                InteractProperty(0, File, State, Ended, MouseIncrement.x, Memory);
                InteractProperty(1, File, State, Ended, MouseIncrement.y, Memory);
            } break;
            case sliding_anchorpoint:
            {
                InteractProperty(2, File, State, Ended, MouseIncrement.x, Memory);
                InteractProperty(3, File, State, Ended, MouseIncrement.y, Memory);
            } break;
            case sliding_rotation:
            {
                InteractProperty(4, File, State, Ended, MouseIncrement.x / 10.0, Memory);
            } break;
            case sliding_scale:
            {
                InteractProperty(5, File, State, Ended, MouseIncrement.x / 200.0, Memory);
            } break;
        }
    }


    if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
        UI->DraggingLayerThreshold = 0;
        UI->DraggingTimelineThreshold = 0;
        UI->DraggingKeyframeThreshold = 0;
    }
}

global_variable char ImGuiPrefs[] = "[Window][DockSpaceViewport_11111111]"
"\nPos=0,0"
"\nSize=3200,1800"
"\nCollapsed=0"
"\n"
"\n[Window][Debug##Default]"
"\nPos=60,60"
"\nSize=400,400"
"\nCollapsed=0"
"\n"
"\n[Window][Viewport]"
"\nPos=528,0"
"\nSize=2168,1171"
"\nCollapsed=0"
"\nDockId=0x00000005,0"
"\n"
"\n[Window][###Properties]"
"\nPos=0,0"
"\nSize=526,1171"
"\nCollapsed=0"
"\nDockId=0x00000003,0"
"\n"
"\n[Window][Timeline]"
"\nPos=0,1173"
"\nSize=3200,627"
"\nCollapsed=0"
"\nDockId=0x00000002,0"
"\n"
"\n[Window][Dear ImGui Demo]"
"\nPos=1881,692"
"\nSize=550,680"
"\nCollapsed=0"
"\n"
"\n[Window][Files]"
"\nPos=2698,0"
"\nSize=502,913"
"\nCollapsed=0"
"\nDockId=0x00000007,0"
"\n"
"\n[Window][Effects list]"
"\nPos=2698,915"
"\nSize=502,256"
"\nCollapsed=0"
"\nDockId=0x00000008,0"
"\n"
"\n[Docking][Data]"
"\nDockSpace         ID=0x8B93E3BD Window=0xA787BDB4 Pos=0,0 Size=3200,1800 Split=Y Selected=0x13926F0B"
"\n  DockNode        ID=0x00000001 Parent=0x8B93E3BD SizeRef=3200,1171 Split=X Selected=0x13926F0B"
"\n    DockNode      ID=0x00000003 Parent=0x00000001 SizeRef=526,1171 Selected=0xDBB8CEFA"
"\n    DockNode      ID=0x00000004 Parent=0x00000001 SizeRef=2672,1171 Split=X Selected=0x13926F0B"
"\n      DockNode    ID=0x00000005 Parent=0x00000004 SizeRef=2115,1171 CentralNode=1 Selected=0x13926F0B"
"\n      DockNode    ID=0x00000006 Parent=0x00000004 SizeRef=502,1171 Split=Y Selected=0x86FA2F90"
"\n        DockNode  ID=0x00000007 Parent=0x00000006 SizeRef=502,913 Selected=0x86FA2F90"
"\n        DockNode  ID=0x00000008 Parent=0x00000006 SizeRef=502,256 Selected=0x812F222D"
"\n  DockNode        ID=0x00000002 Parent=0x8B93E3BD SizeRef=3200,627 HiddenTabBar=1 Selected=0x0F18B61B";