Refactored CertListWidget out of the sidebar

The identity list is needed elsewhere outside of the sidebar, so moved it into a specialized ListWidget class.

1 files changed, 474 insertions, 0 deletions

diff --git a/src/ui/certlistwidget.c b/src/ui/certlistwidget.c
new file mode 100644
index 00000000..4d939ae2
--- /dev/null
+++ b/src/ui/certlistwidget.c
@@ -0,0 +1,474 @@
+/* Copyright 2021 Jaakko Keränen <jaakko.keranen@iki.fi>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+#include "certlistwidget.h"
+
+#include "documentwidget.h"
+#include "command.h"
+#include "labelwidget.h"
+#include "listwidget.h"
+#include "../gmcerts.h"
+#include "../app.h"
+
+#include <SDL_clipboard.h>
+
+iDeclareType(CertItem)
+typedef iListItemClass iCertItemClass;
+
+struct Impl_CertItem {
+    iListItem listItem;
+    uint32_t  id;
+    int       indent;
+    iChar     icon;
+    iBool     isBold;
+    iString   label;
+    iString   meta;
+//    iString   url;
+};
+
+void init_CertItem(iCertItem *d) {
+    init_ListItem(&d->listItem);
+    d->id     = 0;
+    d->indent = 0;
+    d->icon   = 0;
+    d->isBold = iFalse;
+    init_String(&d->label);
+    init_String(&d->meta);
+//    init_String(&d->url);
+}
+
+void deinit_CertItem(iCertItem *d) {
+//    deinit_String(&d->url);
+    deinit_String(&d->meta);
+    deinit_String(&d->label);
+}
+
+static void draw_CertItem_(const iCertItem *d, iPaint *p, iRect itemRect, const iListWidget *list);
+
+iBeginDefineSubclass(CertItem, ListItem)
+    .draw = (iAny *) draw_CertItem_,
+iEndDefineSubclass(CertItem)
+
+iDefineObjectConstruction(CertItem)
+
+/*----------------------------------------------------------------------------------------------*/
+
+struct Impl_CertListWidget {
+    iListWidget  list;
+    int          itemFonts[2];
+    iWidget     *menu;         /* context menu for an item */
+    iCertItem   *contextItem;  /* list item accessed in the context menu */
+    size_t       contextIndex; /* index of list item accessed in the context menu */
+};
+
+iDefineObjectConstruction(CertListWidget)
+
+static iGmIdentity *menuIdentity_CertListWidget_(const iCertListWidget *d) {
+    if (d->contextItem) {
+        return identity_GmCerts(certs_App(), d->contextItem->id);
+    }
+    return NULL;
+}
+
+static void updateContextMenu_CertListWidget_(iCertListWidget *d) {
+    iArray *items = collectNew_Array(sizeof(iMenuItem));
+    pushBackN_Array(items, (iMenuItem[]){
+        { person_Icon " ${ident.use}", 0, 0, "ident.use arg:1" },
+        { close_Icon " ${ident.stopuse}", 0, 0, "ident.use arg:0" },
+        { close_Icon " ${ident.stopuse.all}", 0, 0, "ident.use arg:0 clear:1" },
+        { "---", 0, 0, NULL },
+        { edit_Icon " ${menu.edit.notes}", 0, 0, "ident.edit" },
+        { "${ident.fingerprint}", 0, 0, "ident.fingerprint" },
+        { export_Icon " ${ident.export}", 0, 0, "ident.export" },
+        { "---", 0, 0, NULL },
+        { delete_Icon " " uiTextCaution_ColorEscape "${ident.delete}", 0, 0, "ident.delete confirm:1" },
+    }, 9);
+    /* Used URLs. */
+    const iGmIdentity *ident = menuIdentity_CertListWidget_(d);
+    if (ident) {
+        size_t insertPos = 3;
+        if (!isEmpty_StringSet(ident->useUrls)) {
+            insert_Array(items, insertPos++, &(iMenuItem){ "---", 0, 0, NULL });
+        }
+        const iString *docUrl = url_DocumentWidget(document_App());
+        iBool usedOnCurrentPage = iFalse;
+        iConstForEach(StringSet, i, ident->useUrls) {            
+            const iString *url = i.value;
+            usedOnCurrentPage |= equalCase_String(docUrl, url);
+            iRangecc urlStr = range_String(url);
+            if (startsWith_Rangecc(urlStr, "gemini://")) {
+                urlStr.start += 9; /* omit the default scheme */
+            }
+            insert_Array(items,
+                         insertPos++,
+                         &(iMenuItem){ format_CStr(globe_Icon " %s", cstr_Rangecc(urlStr)),
+                                       0,
+                                       0,
+                                       format_CStr("!open url:%s", cstr_String(url)) });
+        }
+        if (!usedOnCurrentPage) {
+            remove_Array(items, 1);
+        }
+    }
+    destroy_Widget(d->menu);    
+    d->menu = makeMenu_Widget(as_Widget(d), data_Array(items), size_Array(items));    
+}
+
+static void itemClicked_CertListWidget_(iCertListWidget *d, iCertItem *item, size_t itemIndex) {
+    iWidget *w = as_Widget(d);
+    setFocus_Widget(NULL);
+    d->contextItem  = item;
+    if (d->contextIndex != iInvalidPos) {
+        invalidateItem_ListWidget(&d->list, d->contextIndex);
+    }
+    d->contextIndex = itemIndex;
+    if (itemIndex < numItems_ListWidget(&d->list)) {
+        updateContextMenu_CertListWidget_(d);
+        arrange_Widget(d->menu);
+        openMenu_Widget(d->menu,
+                        bounds_Widget(w).pos.x < mid_Rect(rect_Root(w->root)).x
+                            ? topRight_Rect(itemRect_ListWidget(&d->list, itemIndex))
+                            : addX_I2(topLeft_Rect(itemRect_ListWidget(&d->list, itemIndex)),
+                                      -width_Widget(d->menu)));
+    }
+}
+
+static iBool processEvent_CertListWidget_(iCertListWidget *d, const SDL_Event *ev) {
+    iWidget *w = as_Widget(d);
+    /* Handle commands. */
+    if (ev->type == SDL_USEREVENT && ev->user.code == command_UserEventCode) {
+        const char *cmd = command_UserEvent(ev);
+        if (equal_Command(cmd, "idents.changed")) {
+            updateItems_CertListWidget(d);
+        }
+        else if (isCommand_Widget(w, ev, "list.clicked")) {
+            itemClicked_CertListWidget_(
+                d, pointerLabel_Command(cmd, "item"), argU32Label_Command(cmd, "arg"));
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.use")) {
+            iGmIdentity *  ident  = menuIdentity_CertListWidget_(d);
+            const iString *tabUrl = url_DocumentWidget(document_App());
+            if (ident) {
+                if (argLabel_Command(cmd, "clear")) {
+                    clearUse_GmIdentity(ident);
+                }
+                else if (arg_Command(cmd)) {
+                    signIn_GmCerts(certs_App(), ident, tabUrl);
+                    postCommand_App("navigate.reload");
+                }
+                else {
+                    signOut_GmCerts(certs_App(), tabUrl);
+                    postCommand_App("navigate.reload");
+                }
+                saveIdentities_GmCerts(certs_App());
+                updateItems_CertListWidget(d);
+            }
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.edit")) {
+            const iGmIdentity *ident = menuIdentity_CertListWidget_(d);
+            if (ident) {
+                makeValueInput_Widget(get_Root()->widget,
+                                      &ident->notes,
+                                      uiHeading_ColorEscape "${heading.ident.notes}",
+                                      format_CStr(cstr_Lang("dlg.ident.notes"), cstr_String(name_GmIdentity(ident))),
+                                      uiTextAction_ColorEscape "${dlg.default}",
+                                      format_CStr("!ident.setnotes ident:%p ptr:%p", ident, d));
+            }
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.fingerprint")) {
+            const iGmIdentity *ident = menuIdentity_CertListWidget_(d);
+            if (ident) {
+                const iString *fps = collect_String(
+                    hexEncode_Block(collect_Block(fingerprint_TlsCertificate(ident->cert))));
+                SDL_SetClipboardText(cstr_String(fps));
+            }
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.export")) {
+            const iGmIdentity *ident = menuIdentity_CertListWidget_(d);
+            if (ident) {
+                iString *pem = collect_String(pem_TlsCertificate(ident->cert));
+                append_String(pem, collect_String(privateKeyPem_TlsCertificate(ident->cert)));
+                iDocumentWidget *expTab = newTab_App(NULL, iTrue);
+                setUrlAndSource_DocumentWidget(
+                    expTab,
+                    collectNewFormat_String("file:%s.pem", cstr_String(name_GmIdentity(ident))),
+                    collectNewCStr_String("text/plain"),
+                    utf8_String(pem));
+            }
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.setnotes")) {
+            iGmIdentity *ident = pointerLabel_Command(cmd, "ident");
+            if (ident) {
+                setCStr_String(&ident->notes, suffixPtr_Command(cmd, "value"));
+                updateItems_CertListWidget(d);
+            }
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.pickicon")) {
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.reveal")) {
+            const iGmIdentity *ident = menuIdentity_CertListWidget_(d);
+            if (ident) {
+                const iString *crtPath = certificatePath_GmCerts(certs_App(), ident);
+                if (crtPath) {
+                    revealPath_App(crtPath);
+                }
+            }
+            return iTrue;
+        }
+        else if (isCommand_Widget(w, ev, "ident.delete")) {
+            iCertItem *item = d->contextItem;
+            if (argLabel_Command(cmd, "confirm")) {
+                makeQuestion_Widget(
+                    uiTextCaution_ColorEscape "${heading.ident.delete}",
+                    format_CStr(cstr_Lang("dlg.confirm.ident.delete"),
+                                uiTextAction_ColorEscape,
+                                cstr_String(&item->label),
+                                uiText_ColorEscape),
+                    (iMenuItem[]){ { "${cancel}", 0, 0, NULL },
+                                   { uiTextCaution_ColorEscape "${dlg.ident.delete}",
+                                     0,
+                                     0,
+                                     format_CStr("!ident.delete confirm:0 ptr:%p", d) } },
+                    2);
+                return iTrue;
+            }
+            deleteIdentity_GmCerts(certs_App(), menuIdentity_CertListWidget_(d));
+            postCommand_App("idents.changed");
+            return iTrue;
+        }
+    }
+    if (ev->type == SDL_MOUSEMOTION && !isVisible_Widget(d->menu)) {
+        const iInt2 mouse = init_I2(ev->motion.x, ev->motion.y);
+        /* Update cursor. */
+        if (contains_Widget(w, mouse)) {
+            setCursor_Window(get_Window(), SDL_SYSTEM_CURSOR_ARROW);
+        }
+        else if (d->contextIndex != iInvalidPos) {
+            invalidateItem_ListWidget(&d->list, d->contextIndex);
+            d->contextIndex = iInvalidPos;
+        }
+    }
+    /* Update context menu items. */
+    if (ev->type == SDL_MOUSEBUTTONDOWN && ev->button.button == SDL_BUTTON_RIGHT) {
+        d->contextItem = NULL;
+        if (!isVisible_Widget(d->menu)) {
+            updateMouseHover_ListWidget(&d->list);
+        }
+        if (constHoverItem_ListWidget(&d->list) || isVisible_Widget(d->menu)) {
+            d->contextItem = hoverItem_ListWidget(&d->list);
+            /* Context is drawn in hover state. */
+            if (d->contextIndex != iInvalidPos) {
+                invalidateItem_ListWidget(&d->list, d->contextIndex);
+            }
+            d->contextIndex = hoverItemIndex_ListWidget(&d->list);
+            updateContextMenu_CertListWidget_(d);                
+            /* TODO: Some callback-based mechanism would be nice for updating menus right
+               before they open? At least move these to `updateContextMenu_ */
+            const iGmIdentity *ident  = constHoverIdentity_CertListWidget(d);
+            const iString *    docUrl = url_DocumentWidget(document_App());
+            iForEach(ObjectList, i, children_Widget(d->menu)) {
+                if (isInstance_Object(i.object, &Class_LabelWidget)) {
+                    iLabelWidget *menuItem = i.object;
+                    const char *  cmdItem  = cstr_String(command_LabelWidget(menuItem));
+                    if (equal_Command(cmdItem, "ident.use")) {
+                        const iBool cmdUse   = arg_Command(cmdItem) != 0;
+                        const iBool cmdClear = argLabel_Command(cmdItem, "clear") != 0;
+                        setFlags_Widget(
+                            as_Widget(menuItem),
+                            disabled_WidgetFlag,
+                            (cmdClear && !isUsed_GmIdentity(ident)) ||
+                                (!cmdClear && cmdUse && isUsedOn_GmIdentity(ident, docUrl)) ||
+                                (!cmdClear && !cmdUse && !isUsedOn_GmIdentity(ident, docUrl)));
+                    }
+                }
+            }
+        }
+        if (hoverItem_ListWidget(&d->list) || isVisible_Widget(d->menu)) {
+            processContextMenuEvent_Widget(d->menu, ev, {});
+        }
+    }
+    return ((iWidgetClass *) class_Widget(w)->super)->processEvent(w, ev);
+}
+
+static void draw_CertListWidget_(const iCertListWidget *d) {
+    const iWidget *w = constAs_Widget(d);
+    ((iWidgetClass *) class_Widget(w)->super)->draw(w);
+}
+
+static void draw_CertItem_(const iCertItem *d, iPaint *p, iRect itemRect,
+                              const iListWidget *list) {
+    const iCertListWidget *certList = (const iCertListWidget *) list;
+    const iBool isMenuVisible = isVisible_Widget(certList->menu);
+    const iBool isDragging   = constDragItem_ListWidget(list) == d;
+    const iBool isPressing   = isMouseDown_ListWidget(list) && !isDragging;
+    const iBool isHover      =
+            (!isMenuVisible &&
+            isHover_Widget(constAs_Widget(list)) &&
+            constHoverItem_ListWidget(list) == d) ||
+            (isMenuVisible && certList->contextItem == d) ||
+            isDragging;
+    const int itemHeight     = height_Rect(itemRect);
+    const int iconColor      = isHover ? (isPressing ? uiTextPressed_ColorId : uiIconHover_ColorId)
+                                       : uiIcon_ColorId;
+    const int altIconColor   = isPressing ? uiTextPressed_ColorId : uiTextCaution_ColorId;
+    const int font = certList->itemFonts[d->isBold ? 1 : 0];
+    int bg         = uiBackgroundSidebar_ColorId;
+    if (isHover) {
+        bg = isPressing ? uiBackgroundPressed_ColorId
+                        : uiBackgroundFramelessHover_ColorId;
+        fillRect_Paint(p, itemRect, bg);
+    }
+    else if (d->listItem.isSelected) {
+        bg = uiBackgroundUnfocusedSelection_ColorId;
+        fillRect_Paint(p, itemRect, bg);
+    }
+//    iInt2 pos = itemRect.pos; 
+    const int fg = isHover ? (isPressing ? uiTextPressed_ColorId : uiTextFramelessHover_ColorId)
+                           : uiTextStrong_ColorId;
+    const iBool isUsedOnDomain = (d->indent != 0);
+    iString icon;
+    initUnicodeN_String(&icon, &d->icon, 1);
+    iInt2 cPos = topLeft_Rect(itemRect);
+    const int indent = 1.4f * lineHeight_Text(font);
+    addv_I2(&cPos,
+            init_I2(3 * gap_UI,
+                    (itemHeight - lineHeight_Text(uiLabel_FontId) * 2 - lineHeight_Text(font)) /
+                        2));
+    const int metaFg = isHover ? permanent_ColorId | (isPressing ? uiTextPressed_ColorId
+                                                                 : uiTextFramelessHover_ColorId)
+                               : uiTextDim_ColorId;
+    if (!d->listItem.isSelected && !isUsedOnDomain) {
+        drawOutline_Text(font, cPos, metaFg, none_ColorId, range_String(&icon));
+    }
+    drawRange_Text(font,
+                   cPos,
+                   d->listItem.isSelected ? iconColor
+                   : isUsedOnDomain       ? altIconColor
+                                          : uiBackgroundSidebar_ColorId,
+                   range_String(&icon));
+    deinit_String(&icon);
+    drawRange_Text(d->listItem.isSelected ? certList->itemFonts[1] : font,
+                   add_I2(cPos, init_I2(indent, 0)),
+                   fg,
+                   range_String(&d->label));
+    drawRange_Text(uiLabel_FontId,
+                   add_I2(cPos, init_I2(indent, lineHeight_Text(font))),
+                   metaFg,
+                   range_String(&d->meta));
+}
+
+void init_CertListWidget(iCertListWidget *d) {
+    iWidget *w = as_Widget(d);
+    init_ListWidget(&d->list);
+    setId_Widget(w, "certlist");
+    setBackgroundColor_Widget(w, none_ColorId);
+    d->itemFonts[0] = uiContent_FontId;
+    d->itemFonts[1] = uiContentBold_FontId;
+#if defined (iPlatformMobile)
+    if (deviceType_App() == phone_AppDeviceType) {
+        d->itemFonts[0] = uiLabelBig_FontId;
+        d->itemFonts[1] = uiLabelBigBold_FontId;
+    }
+#endif
+    d->menu = NULL;
+    d->contextItem = NULL;
+    d->contextIndex = iInvalidPos;
+}
+
+void updateItemHeight_CertListWidget(iCertListWidget *d) {
+    setItemHeight_ListWidget(&d->list, 3.5f * lineHeight_Text(d->itemFonts[0]));
+}
+
+iBool updateItems_CertListWidget(iCertListWidget *d) {
+    clear_ListWidget(&d->list);
+    destroy_Widget(d->menu);
+    d->menu       = NULL;
+    const iString *tabUrl = url_DocumentWidget(document_App());
+    const iRangecc tabHost = urlHost_String(tabUrl);
+    iBool haveItems = iFalse;
+    iConstForEach(PtrArray, i, identities_GmCerts(certs_App())) {
+        const iGmIdentity *ident = i.ptr;
+        iCertItem *item = new_CertItem();
+        item->id = (uint32_t) index_PtrArrayConstIterator(&i);
+        item->icon = 0x1f464; /* person */
+        set_String(&item->label, name_GmIdentity(ident));
+        iDate until;
+        validUntil_TlsCertificate(ident->cert, &until);
+        const iBool isActive = isUsedOn_GmIdentity(ident, tabUrl);
+        format_String(&item->meta,
+                      "%s",
+                      isActive ? cstr_Lang("ident.using")
+                      : isUsed_GmIdentity(ident)
+                          ? formatCStrs_Lang("ident.usedonurls.n", size_StringSet(ident->useUrls))
+                          : cstr_Lang("ident.notused"));
+        const char *expiry =
+            ident->flags & temporary_GmIdentityFlag
+                ? cstr_Lang("ident.temporary")
+                : cstrCollect_String(format_Date(&until, cstr_Lang("ident.expiry")));
+        if (isEmpty_String(&ident->notes)) {
+            appendFormat_String(&item->meta, "\n%s", expiry);
+        }
+        else {
+            appendFormat_String(&item->meta,
+                                " \u2014 %s\n%s%s",
+                                expiry,
+                                escape_Color(uiHeading_ColorId),
+                                cstr_String(&ident->notes));
+        }
+        item->listItem.isSelected = isActive;
+        if (isUsedOnDomain_GmIdentity(ident, tabHost)) {
+            item->indent = 1; /* will be highlighted */
+        }
+        addItem_ListWidget(&d->list, item);
+        haveItems = iTrue;
+        iRelease(item);
+    }
+    return haveItems;
+}
+
+void deinit_CertListWidget(iCertListWidget *d) {
+    iUnused(d);
+}
+
+const iGmIdentity *constHoverIdentity_CertListWidget(const iCertListWidget *d) {
+    const iCertItem *hoverItem = constHoverItem_ListWidget(&d->list);
+    if (hoverItem) {
+        return identity_GmCerts(certs_App(), hoverItem->id);
+    }
+    return NULL;
+}
+
+iGmIdentity *hoverIdentity_CertListWidget(const iCertListWidget *d) {
+    return iConstCast(iGmIdentity *, constHoverIdentity_CertListWidget(d));
+}
+
+iBeginDefineSubclass(CertListWidget, ListWidget)
+    .processEvent = (iAny *) processEvent_CertListWidget_,
+    .draw         = (iAny *) draw_CertListWidget_,
+iEndDefineSubclass(CertListWidget)