gene b.'s questions

Por algum motivo, quando uso a SHFormatDateTimefunção da API do Win32 para obter a Data de Modificação de um arquivo, com qualquer sinalizador, ela acrescenta alguns caracteres especiais estranhos, como a seguir.

Isso ocorre no contexto de loop pelos arquivos ( WIN32_FIND_DATAA findData), o que pode ou não ser relevante aqui.

Versão ANSI simples - SHFormatDateTimeA:

hFind = FindFirstFileA(full_path.c_str(), &findData);
while (FindNextFileA(hFind, &findData) != 0) {   

    char datebuf[80];
    DWORD flags = FDTF_DEFAULT;
    SHFormatDateTimeA(&findData.ftLastWriteTime, &flags, datebuf, 80);
    std::string lastModifiedDateStr = std::string(datebuf);

Saída:?4/?25/?2025 ??9:44 AM

Versão Unicode - SHFormatDateTimeW:

    wchar_t datebuf[80];
    DWORD flags = FDTF_DEFAULT;
    SHFormatDateTimeW(&findData.ftLastWriteTime, &flags, datebuf, 80);
    std::wstring lastModifiedDateStr = std::wstring(datebuf);

Saída:u+200E‎ 4 / ‎u+200E 25 / ‎u+200E 2025 u+200F u+200E ‏‎9 : 44 AM

Portanto, independentemente de ANSI/Unicode, a função SHFormatDateTimeadiciona alguns caracteres estranhos antes de cada parte. Tentei várias flags, como FDTF_DEFAULT, FDTF_SHORTDATEe até NULL. Não tenho esse problema com outras funções da API WIn32 do Shell.

No Win32, existem muitos tipos diferentes de identificadores, como HWND, HFONT, HIMAGELISTetc. Entendo que é minha responsabilidade fechar todos eles no final com DeleteObject(). Além disso, alguns tipos de identificadores, como , HIMAGELISTtêm funções adicionais ImageList_Destroy, como , então preciso chamá-los também.

Quero verificar se os identificadores se tornam inválidos depois de limpá-los. Suponha que eu tenha

HWND hWnd;
HFONT hFont;
HIMAGELIST hImageList;

//...
// On Exit:
case WM_DESTROY:
    DeleteObject(hWnd);
    DeleteObject(hFont);
    ImageList_Destroy(hImageList);
    DeleteObject(hImageList);

No depurador do VS, vejo que o valor dos identificadores não muda após essas exclusões. É exatamente o mesmo, tanto antes quanto depois:

hWnd        0x00000000e806b2
hFont       0xfffffffe20a140
hImageList  0x000001c76a943e

Isso deveria mudar? Como sei que estou limpando essas alças?

No meu aplicativo Win32, tenho uma barra de ferramentas que precisa ter uma caixa de combinação principal suspensa abrangendo 70% da barra de ferramentas, começando pela esquerda, e depois quaisquer botões adicionais (como neste caso Recortar/Copiar/Colar) seguindo depois — talvez depois de um pequeno separador.

[--------------------Dropdown-------------------V] | [Cut][Copy][Paste]

Neste código, primeiro crio o controle ComboBox filho para a barra de ferramentas e faço com que ele tenha 70% da largura do Toolbar Rect usando setWindowPose então prossigo com botões regulares. Mas apenas os 3 botões são exibidos sem o ComboBox.

Acho que tenho que fazer isso SetWindowPospara cada um dos botões, mas quero que eles fluam naturalmente sem posicioná-los explicitamente, como aconteceria sem a caixa de combinação.

void CreateToolbar1(HWND hWndParent)
{
    // Declare and initialize local constants.
    const int ImageListID = 0;
    const int numButtons = 3;
    const int bitmapSize = 16;

    const DWORD buttonStyles = BTNS_AUTOSIZE;

    // Create the toolbar.
    hWndToolbar1 = CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
        WS_CHILD | TBSTYLE_WRAPABLE | TBSTYLE_FLAT, 0, 0, 0, 0,
        hWndParent, NULL, GetModuleHandle(NULL), NULL);

    // Obtain toolbar's rectangle coordinates
    RECT rectToolbar1;
    SendMessage(hWndToolbar1, TB_GETITEMRECT, (WPARAM)0, (LPARAM)&rectToolbar1);

    // Add ComboBox control to toolbar, should take up 70% of the width
    HWND hWndDropdown = CreateWindowEx(WS_EX_CLIENTEDGE, WC_COMBOBOXEX, NULL, WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST, 0, 0, 100, 35, hWndToolbar1, NULL, GetModuleHandle(NULL), NULL);
    SetWindowPos(hWndDropdown, NULL, rectToolbar1.left, rectToolbar1.top, 0.7 * (rectToolbar1.right - rectToolbar1.left), rectToolbar1.bottom - rectToolbar1.top, SWP_SHOWWINDOW);

    // Add 3 regular buttons afterwards (Cut/Copy/Paste)
    // ---
    // Create the image list.
    g_hImageList = ImageList_Create(bitmapSize, bitmapSize,   // Dimensions of individual bitmaps.
        ILC_COLOR16 | ILC_MASK,   // Ensures transparent background.
        numButtons, 0);

    // Set the image list.
    SendMessage(hWndToolbar1, TB_SETIMAGELIST,
        (WPARAM)ImageListID,
        (LPARAM)g_hImageList);

    // Load the button images.
    SendMessage(hWndToolbar1, TB_LOADIMAGES,
        (WPARAM)IDB_STD_SMALL_COLOR,
        (LPARAM)HINST_COMMCTRL);

    // Initialize buttons Cut/Copy/Paste
    TBBUTTON tbButtons[numButtons] =
    {
        { MAKELONG(STD_CUT,  ImageListID), IDM_CUT,  TBSTATE_ENABLED, buttonStyles, {0}, 0, (INT_PTR)L"Cut" },
        { MAKELONG(STD_COPY, ImageListID), IDM_COPY, TBSTATE_ENABLED, buttonStyles, {0}, 0, (INT_PTR)L"Copy"},
        { MAKELONG(STD_PASTE, ImageListID), IDM_PASTE, 0,               buttonStyles, {0}, 0, (INT_PTR)L"Paste"}
    };

    // Add buttons.
    SendMessage(hWndToolbar1, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
    SendMessage(hWndToolbar1, TB_ADDBUTTONS, (WPARAM)numButtons, (LPARAM)&tbButtons);

    // Resize the toolbar, and then show it.
    SendMessage(hWndToolbar1, TB_AUTOSIZE, 0, 0);
    ShowWindow(hWndToolbar1, TRUE);

}

Tenho uma função assíncrona que busca um objeto DB ( Referral). Além da busca principal, várias outras partes do aplicativo também buscam auxiliares Referralspor meio da mesma função exata e sua lógica.

Uma função async não pode retornar nada, então não pode ser usada como um retorno genérico. Em vez disso, temos que definir uma variável de estado com os resultados dela.

Se eu fizer

const [mainReferral, setMainReferral] = useState<Referral|null>(null);

// Fetch main referral
const fetchReferral = async (referralId:string) => {
    const response = await get<any>("/referral/" + referralId);
    // Lots of logic below, e.g.
    response['specialDerivedField1'] = ...;
    response['specialDerivedField2'] = ...;
    //...
    setMainReferral(response);
}

Isso só lida com o caso único da referência principal. Eu também posso ter

const [auxReferral1, setAuxReferral1] = useState<Referral|null>(null);
const [auxReferral2, setAuxReferral2] = useState<Referral|null>(null);
//...

Eu realmente tenho que adicionar parâmetros diferentes a essa função para decidir o que definir com um if-else? Isso não parece muito robusto para mim.

const fetchReferral = async (referralId:string, case1:boolean, case2:boolean) => {
   //... 
   if (case1) 
      setAuxReferral1(response);
   else if (case2) {
      setAuxReferral2(response);
   else {
      setMainReferral(response);
   }
}

Alguma outra prática recomendada para isso? Ou talvez passar uma string para o nome da variável de estado e então encontrar o setter para ela pelo nome (não tenho certeza se o React suporta isso)?

Eu também adoraria isolar essa função utilitária em um arquivo utilitário separado que não lidasse com estado, mas como uma asyncfunção isso seria impossível, eu acho?

Eu tenho um procedimento armazenado externo que está chamando um procedimento armazenado interno em um loop. O procedimento armazenado interno retorna um REF CURSORcomposto por 2 partes, (1) V_SUCCESSFUL_COUNT(2) V_RESPONSE_CODE.

Meu procedimento armazenado externo está coletando esses pares de todas as chamadas de procedimento armazenado interno nas matrizes correspondentes V_SUCCESSFUL_COUNTSe V_RESPONSE_CODES. Primeiro ele abre o cursor do procedimento armazenado interno, busca as duas partes em variáveis ​​e depois adiciona essas variáveis ​​aos arrays.

PROCEDURE OUTER_SP(PARAM1, .., P_REF_CURSOR REF CURSOR)
AS
    ..
    V_SUCCESSFUL_COUNT      NUMBER;
    V_RESPONSE_CODE         VARCHAR2(10);
    V_SUCCESSFUL_COUNTS     REF_TYPE_NUM_TABLE := REF_TYPE_NUM_TABLE(); /* Cumulative Successful Counts */
    V_RESPONSE_CODES        REF_VARCHAR2_ARRAY_TABLE := REF_VARCHAR2_ARRAY_TABLE(); /* Cumulative Response Codes */
    V_REF_CURSOR            SYS_REFCURSOR; /* Result from each inner SP */

    FOR i IN 1 .. P_REF_ID_LIST.COUNT LOOP
                    SP_INNER(PARAM1,
                             PARAM2,
                             ...
                             V_REF_CURSOR);

        /* Add V_SUCCESSFUL_COUNT, V_RESPONSE_CODE outputs from this call to collections */
        OPEN V_REF_CURSOR /* Error here! */;
        FETCH V_REF_CURSOR INTO V_SUCCESSFUL_COUNT, V_RESPONSE_CODE;
        V_SUCCESSFUL_COUNTS.EXTEND;
        V_SUCCESSFUL_COUNTS(V_SUCCESSFUL_COUNTS.COUNT) := V_SUCCESSFUL_COUNT;
        V_RESPONSE_CODES.EXTEND;
        V_RESPONSE_CODES(V_RESPONSE_CODES.COUNT) := V_RESPONSE_CODE;
        CLOSE V_REF_CURSOR /* Error here! */;
    END LOOP;

Estou recebendo esse erro nas linhas

OPEN V_REF_CURSOR / CLOSE V_REF_CURSOR

enquanto tento recuperar o resultado de cada chamada de procedimento armazenado interno:

PLS-00382: a expressão é do tipo errado

Não gosto que eu abra o cursor do procedimento armazenado interno antes de chamar FETCH V_REF_CURSOR.

Se eu remover essas linhas OPEN V_REF_CURSOR/ CLOSE V_REF_CURSORe for direto para FETCH V_REF_CURSOR, não haverá erro de sintaxe e o procedimento armazenado será compilado, mas os resultados adicionados ao array estarão incorretos ( NULL), como posso ver quando executo esse procedimento armazenado externo.

Eu tenho um DIV de contêiner externo centralizado com um Flex ( display:flex, justify-content:center) e em algum lugar entre seus descendentes uma Tabela cujo DIV de wrapper imediato possui uma overflow-x:autobarra de rolagem horizontal para suportar a rolagem horizontal da tabela.

O exemplo 2 funciona corretamente desde o ponto inicial e conforme você redimensiona a janela. A tabela começa centralizada e se você redimensionar, ao transbordar, você verá a barra de rolagem horizontal. Neste exemplo, a Tabela está diretamente abaixo do pai centrado no Container Flex.

Mas tenho o Exemplo 1 com uma hierarquia mais profunda, com apenas alguns DIVs adicionados. Agora ao redimensionar, a tabela não obedece ao overflow e não mostra mais a barra de rolagem.

Nota: Execute em uma página inteira para ver apenas a Tabela 2 com a barra de rolagem no redimensionamento. Preciso manter o Flex Top Parent para que o contêiner externo fique centralizado, mas não quero que ele se aplique ao wrapper da tabela com o overflow-x.

.tableWrapper {
  overflow-x: auto;
}

.container {
  display: flex;
  justify-content: center;
  border-left: 2px solid red;
  border-right: 2px solid red;
}

<div class="container">
  <div>
     <div>
        <div class="tableWrapper">

          <table>
             <thead>
               <th>Column 1</th>
               <th>Column 2</th>
               <th>Column 3</th>
               <th>Column 4</th>
               <th>Column 5</th>
               <th>Column 6</th>
               <th>Column 7</th>
               <th>Column 8</th>
             </thead>
             <tbody>
               <tr>
                  <td>1111111</td><td>2222222</td><td>33333333</td><td>444444444</td><td>55555555</td><td>6666666</td><td>77777777</td><td>88888888</td>
               </tr>
             </tbody>
          </table>
        </div>
    </div>
 </div>
 </div>
 
 <br/><br/><br/>
 
 <div class="container">
        <div class="tableWrapper">

          <table>
             <thead>
               <th>Column 1</th>
               <th>Column 2</th>
               <th>Column 3</th>
               <th>Column 4</th>
               <th>Column 5</th>
               <th>Column 6</th>
               <th>Column 7</th>
               <th>Column 8</th>
             </thead>
             <tbody>
               <tr>
                  <td>1111111</td><td>2222222</td><td>33333333</td><td>444444444</td><td>55555555</td><td>6666666</td><td>77777777</td><td>88888888</td>
               </tr>
             </tbody>
          </table>
    </div>
</div>

No SqlDeveloper estou tentando executar o seguinte SQL EXECUTE multilinha com comentários,

execute MYPKG.MYSP (null/*Param1*/, null/*Param2*/, 123/*Param3*/, 
                    null/*Param4*/, etc.

Na primeira nova linha sinaliza o erro

execute MYPKG.MYSP (null/*Param1*/, null/*Param2*/, 123/*Param3*/, ; END;
ORA-06550: line 1, column 131:
PLS-00103: Encountered the symbol ";" when expecting one of the following:

   ( - + case mod new not null <an identifier>
   <a double-quoted delimited-identifier> <a bind variable>
   continue avg count current exists max min prior sql stddev
   sum variance execute forall merge time timestamp interval
   date <a string literal with character set specification>
   <a number> <a single-quoted SQL string> pipe
   <an alternatively-quoted st

e em cada nova linha subsequente depois disso

Error report -
Unknown Command

Não há ; em qualquer lugar nessas novas linhas. Como executo um SQL formatado em várias linhas sem reclamar de novas linhas ou comentários?

Para uma variável de estado React que é um objeto, preciso atualizar uma propriedade em um objeto e retornar um novo objeto. Estou comparando as seguintes abordagens:

setFormData(Object.assign({}, formData, {b: 22}));

vs.

setFormData((prevData) => ({
            ...prevData,
            b: 22
        }));

Outra opção possível é, sem usar a função de seta,

setFormData( { ...prevData, "b": 22 } )

Tudo isso é válido e há uma razão para usar um em vez de outro?

Tenho os seguintes problemas com o TDateTimePickercontrole:

(1) Quando o formulário aparece, ele é automaticamente focado. É meu primeiro controle no formulário, mas tudo precisa ser desfocado na inicialização. Eu tentei o seguinte:

procedure TfrmMain.FormShow(Sender: TObject);
begin
  // ...
  // Defocus everything
   Self.ActiveControl := nil; // Does not work
end;

(2) Além disso, existe um TSpeedButtonque deve desfocar este controle, mas pressioná-lo não remove o foco do TDateTimePicker. (Outros controles, como o normal, TButtono removem.)