Delphi - znázornění průběhu v Gauge



dobrý denpři kopírovíní souborů, bych chtěla průběh kopírování znázornit v Gauge. Zkoušela jsem to takhle: c := c-1;  f := f+1; g := c / 100; //počet soubrů v procentech Label\_vstup.Caption := IntToStr(c); // vstupní počet souborů Label\_vystup.Caption := IntToStr(f); //počet již zkopírovaných souborů Gauge1.MinValue := 0; Gauge1.MaxValue := c; Gauge1.Progress := g; //tady mi to hlásí nekopmpatibilní typ zkoušela jsem různě přetypovávat, ale stále se mi nedaří ![](/Client.Images/smileys/8.gif)děkuji za odpověď
Vypadá to, že "g" musí být typ integer a po dělení je z něj real. Zkus dátg:=Round( c/100 );
<p>ve skutečnosti to není samo o sobě vzorec uživatelského rozhraní, ale gmail a google reader v zásadě standardizovaly toto chování ve webových aplikacích a od té doby jsem se ho snažil sledovat:</p><ul> <li>žádné vstupní pole konkrétně; stačí nechat aplikaci reagovat na stisknutí kláves po celou dobu (s výjimkou zaměření na vstupní pole)</li> <li>typ? (shift + /) otevřete překrytí klávesové zkratky kdekoli v aplikaci.</li> <li>j &amp; k pro pohyb vpřed a vzad v kontextu, jako jsou e-maily nebo položky rss</li> <li>sekvence: například zadáním „g“ následovaným „i“ v gmailu „přejde“ do „doručené“</li> <li>namapujte co nejvíce klávesových zkratek na klávesy odpovídající akci, což by mělo pomoci zapamatování. "c" v gmailu znamená "napsat". výjimky z tohoto pravidla: další převažující konvence, jako jsou výše uvedené klíče j/k.</li> </ul><p>funkce „sekvence“ umožňuje reagovat na jednotlivá stisknutí kláves, aniž by uživatelé museli psát slova, a to (teoreticky) vám dává neomezené kombinace stisknutí kláves, protože máte tucet možností na klávesu v sekvenci. v této architektuře byste měli být schopni implementovat většinu příkazů, které chcete.</p><p>opravdu se mi líbí, jak to google implementoval - je příliš špatné, že to opravdu někde extrapolovali na návrhové vzory (pokud to neudělali a já mi to chybělo). bylo by hezké vidět více aplikací sledovat trend, který nastavily.</p> <p>příkaz <code>merge</code> má složitou syntaxi a ještě složitější implementaci, ale v zásadě jde o spojení dvou tabulek, filtrování dolů na řádky, které je třeba změnit (vložit, aktualizovat nebo smazat), a poté provést požadované změny. vzhledem k těmto vzorovým údajům:</p><pre><code>declare @categoryitem as table ( categoryid integer not null, itemid integer not null, primary key (categoryid, itemid), unique (itemid, categoryid) ); declare @datasource as table ( categoryid integer not null, itemid integer not null primary key (categoryid, itemid) ); insert @categoryitem (categoryid, itemid) values (1, 1), (1, 2), (1, 3), (2, 1), (2, 3), (3, 5), (3, 6), (4, 5); insert @datasource (categoryid, itemid) values (2, 2); </code></pre><p><strong> cíl </strong></p><pre><code>╔════════════╦════════╗ ║ categoryid ║ itemid ║ ╠════════════╬════════╣ ║ 1 ║ 1 ║ ║ 2 ║ 1 ║ ║ 1 ║ 2 ║ ║ 1 ║ 3 ║ ║ 2 ║ 3 ║ ║ 3 ║ 5 ║ ║ 4 ║ 5 ║ ║ 3 ║ 6 ║ ╚════════════╩════════╝ </code></pre><p><strong> zdroj </strong></p><pre><code>╔════════════╦════════╗ ║ categoryid ║ itemid ║ ╠════════════╬════════╣ ║ 2 ║ 2 ║ ╚════════════╩════════╝ </code></pre><p>požadovaným výsledkem je nahrazení dat v cíli daty ze zdroje, ale pouze pro <code>categoryid = 2</code>. po výše uvedeném popisu <code>merge</code> bychom měli napsat dotaz, který spojuje zdroj a cíl pouze na klíče, a filtrovat řádky pouze v klauzulích <code>when</code>:</p><pre><code>merge into @categoryitem as target using @datasource as source on source.itemid = target.itemid and source.categoryid = target.categoryid when not matched by source and target.categoryid = 2 then delete when not matched by target and source.categoryid = 2 then insert (categoryid, itemid) values (categoryid, itemid) output $action, isnull(inserted.categoryid, deleted.categoryid) as categoryid, isnull(inserted.itemid, deleted.itemid) as itemid ; </code></pre><p>to dává následující výsledky:</p><pre><code>╔═════════╦════════════╦════════╗ ║ $action ║ categoryid ║ itemid ║ ╠═════════╬════════════╬════════╣ ║ delete ║ 2 ║ 1 ║ ║ insert ║ 2 ║ 2 ║ ║ delete ║ 2 ║ 3 ║ ╚═════════╩════════════╩════════╝ ╔════════════╦════════╗ ║ categoryid ║ itemid ║ ╠════════════╬════════╣ ║ 1 ║ 1 ║ ║ 1 ║ 2 ║ ║ 1 ║ 3 ║ ║ 2 ║ 2 ║ ║ 3 ║ 5 ║ ║ 3 ║ 6 ║ ║ 4 ║ 5 ║ ╚════════════╩════════╝ </code></pre><p>realizační plán je: <img src="https://i.stack.imgur.com/fovhu.jpg" alt="merge plan"></p><p>všimněte si, že jsou obě tabulky plně naskenovány. můžeme to považovat za neefektivní, protože pouze řádky, kde <code>categoryid = 2</code> bude ovlivněno v cílové tabulce. zde přicházejí varování v books online. jeden chybný pokus o optimalizaci, aby se dotkl pouze nezbytných řádků v cíli, je:</p><pre><code>merge into @categoryitem as target using ( select categoryid, itemid from @datasource as ds where categoryid = 2 ) as source on source.itemid = target.itemid and target.categoryid = 2 when not matched by target then insert (categoryid, itemid) values (categoryid, itemid) when not matched by source then delete output $action, isnull(inserted.categoryid, deleted.categoryid) as categoryid, isnull(inserted.itemid, deleted.itemid) as itemid ; </code></pre><p>logika v klauzuli <code>on</code> je použita jako součást spojení. v tomto případě je spojení úplným vnějším spojením (viz <a href="http://technet.microsoft.com/en-us/library/bb522522%28v=sql.105%29.aspx">tento záznam books online</a> proč). použití kontroly kategorie 2 na cílových řádcích jako součásti vnějšího spojení nakonec povede k odstranění řádků s jinou hodnotou (protože neodpovídají zdroji):</p><pre><code>╔═════════╦════════════╦════════╗ ║ $action ║ categoryid ║ itemid ║ ╠═════════╬════════════╬════════╣ ║ delete ║ 1 ║ 1 ║ ║ delete ║ 1 ║ 2 ║ ║ delete ║ 1 ║ 3 ║ ║ delete ║ 2 ║ 1 ║ ║ insert ║ 2 ║ 2 ║ ║ delete ║ 2 ║ 3 ║ ║ delete ║ 3 ║ 5 ║ ║ delete ║ 3 ║ 6 ║ ║ delete ║ 4 ║ 5 ║ ╚═════════╩════════════╩════════╝ ╔════════════╦════════╗ ║ categoryid ║ itemid ║ ╠════════════╬════════╣ ║ 2 ║ 2 ║ ╚════════════╩════════╝ </code></pre><p>kořenová příčina je ze stejného důvodu, proč se predikáty chovají v klauzuli vnější spojení <code>on</code> odlišně, než když jsou specifikovány v klauzuli <code>where</code>. syntaxe <code>merge</code> (a implementace spojení v závislosti na zadaných klauzulích) jen ztěžují vidět, že tomu tak je.</p><p> <a href="http://technet.microsoft.com/en-us/library/bb510625%28v=sql.105%29.aspx">navádění v books online</a> (rozšířeno v položce <a href="http://technet.microsoft.com/en-us/library/cc879317%28v=sql.105%29.aspx">optimizing performance</a> ) nabízí navádění, které zajistí, že správná sémantika je vyjádřena pomocí syntaxe <code>merge</code>, aniž by uživatel nutně musel muset pochopit všechny podrobnosti implementace nebo zohlednit způsoby, kterými by optimalizátor mohl legitimně přeskupit věci z důvodů efektivnosti provádění.</p><p>dokumentace nabízí tři možné způsoby implementace časného filtrování:</p><p><strong> zadání podmínky filtrování v klauzuli <code>when</code> </strong> zaručuje správné výsledky, ale může znamenat, že více řádků je čteno a zpracováno ze zdroje a cíle tabulky, než je nezbytně nutné (viz první příklad).</p><p><strong> aktualizace prostřednictvím zobrazení </strong>, která obsahuje podmínku filtrování, také zaručuje správné výsledky (protože změněné řádky musí být přístupné pro aktualizaci prostřednictvím zobrazení), ale vyžaduje to vyhrazené zobrazení, které splňuje liché podmínky pro aktualizaci zobrazení.</p><p><strong> použití společného výrazu tabulky </strong> přináší podobné riziko při přidávání predikátů k klauzuli <code>on</code>, ale z poněkud odlišných důvodů. v mnoha případech to bude bezpečné, ale vyžaduje to odbornou analýzu prováděcího plánu, aby se to potvrdilo (a rozsáhlé praktické testování). například:</p><pre><code>with target as ( select * from @categoryitem where categoryid = 2 ) merge into target using ( select categoryid, itemid from @datasource where categoryid = 2 ) as source on source.itemid = target.itemid and source.categoryid = target.categoryid when not matched by target then insert (categoryid, itemid) values (categoryid, itemid) when not matched by source then delete output $action, isnull(inserted.categoryid, deleted.categoryid) as categoryid, isnull(inserted.itemid, deleted.itemid) as itemid ; </code></pre><p>výsledkem jsou správné výsledky (neopakované) s optimálnějším plánem:</p><p><img src="https://i.stack.imgur.com/tazmk.jpg" alt="merge plan 2"></p><p>plán čte pouze řádky pro kategorii 2 z cílové tabulky. to může být důležitým hlediskem výkonu, pokud je cílová tabulka velká, ale je příliš snadné tuto chybu získat pomocí syntaxe <code>merge</code>.</p><p>někdy je snazší zapsat <code>merge</code> jako samostatné operace dml. tento přístup může dokonce <strong> vést lépe </strong> než jediný <code>merge</code>, což je skutečnost, která lidi často překvapuje.</p><pre><code>delete ci from @categoryitem as ci where ci.categoryid = 2 and not exists ( select 1 from @datasource as ds where ds.itemid = ci.itemid and ds.categoryid = ci.categoryid ); insert @categoryitem select ds.categoryid, ds.itemid from @datasource as ds where ds.categoryid = 2; </code></pre> <p>zjistil jsem, že david eppstein má <a href="http://www.ics.uci.edu/~eppstein/numth/frap.c">racionální aproximaci k danému reálnému číslu</a> c kód, který je přesně to, o co žádáte. jeho základem je teorie pokračujících zlomků a velmi rychlá a poměrně kompaktní.</p><p>použil jsem verze tohoto přizpůsobené pro konkrétní limity čitatele a jmenovatele.</p><pre><code>/* ** find rational approximation to given real number ** david eppstein / uc irvine / 8 aug 1993 ** ** with corrections from arno formella, may 2008 ** ** usage: a.out r d ** r is real number to approx ** d is the maximum denominator allowed ** ** based on the theory of continued fractions ** if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...))) ** then best approximation is found by truncating this series ** (with some adjustments in the last term). ** ** note the fraction can be recovered as the first column of the matrix ** ( a1 1 ) ( a2 1 ) ( a3 1 ) ... ** ( 1 0 ) ( 1 0 ) ( 1 0 ) ** instead of keeping the sequence of continued fraction terms, ** we just keep the last partial product of these matrices. */ #include &lt;stdio.h&gt; main(ac, av) int ac; char ** av; { double atof(); int atoi(); void exit(); long m[2][2]; double x, startx; long maxden; long ai; /* read command line arguments */ if (ac != 3) { fprintf(stderr, "usage: %s r d\n",av[0]); // af: argument missing exit(1); } startx = x = atof(av[1]); maxden = atoi(av[2]); /* initialize matrix */ m[0][0] = m[1][1] = 1; m[0][1] = m[1][0] = 0; /* loop finding terms until denom gets too big */ while (m[1][0] * ( ai = (long)x ) + m[1][1] &lt;= maxden) { long t; t = m[0][0] * ai + m[0][1]; m[0][1] = m[0][0]; m[0][0] = t; t = m[1][0] * ai + m[1][1]; m[1][1] = m[1][0]; m[1][0] = t; if(x==(double)ai) break; // af: division by zero x = 1/(x - (double) ai); if(x&gt;(double)0x7fffffff) break; // af: representation failure } /* now remaining x is between 0 and 1/ai */ /* approx as either 0 or 1/m where m is max that will fit in maxden */ /* first try zero */ printf("%ld/%ld, error = %e\n", m[0][0], m[1][0], startx - ((double) m[0][0] / (double) m[1][0])); /* now try other possibility */ ai = (maxden - m[1][1]) / m[1][0]; m[0][0] = m[0][0] * ai + m[0][1]; m[1][0] = m[1][0] * ai + m[1][1]; printf("%ld/%ld, error = %e\n", m[0][0], m[1][0], startx - ((double) m[0][0] / (double) m[1][0])); } </code></pre> Říkáte, že máte dostatek potíže jednu kostku, aby zobrazoval ... takže jsem si jistý, jestli máte jeden pro zobrazení nebo ne.


V podstatě ... dát svůj kód pro psaní kostku v jedné funkci, pak už jen volání funkce 100krát.



```
void DrawCube()
{
    //code to draw the cube
}

void DisplayCubes()
{
    for(int i = 0; i < 10; ++i)
    {   
         for(int j = 0; j < 10; ++j)
         {
             glPushMatrix();
             //alter these values depending on the size of your cubes.
             //This call makes sure that your cubes aren't drawn overtop of each other
             glTranslatef(i*5.0, j*5.0, 0);
             DrawCube();
             glPopMatrix();
         }
    }              
}

```

To je základní přehled o tom, jak byste mohli jít o to udělat. Pokud se chcete něco účinnější nahlédnout do display listy někdy Jakmile budete mít základy přišel :) <p><strong> edit: </strong>první kontrola, pokud jste nevyčerpali místo na disku, před vyřešením rozlišení souvisejícího s konfigurací.</p><p>zdá se, že máte příliš nízkou maximální velikost <code>innodb\_data\_file\_path</code> ve vašem <code>my.cnf</code>, v tomto příkladu</p><pre><code>innodb\_data\_file\_path = ibdata1:10m:autoextend:max:512m </code></pre><p>nelze kombinovat více než 512 mb dat ve všech tabulkách inodbb.</p><p>možná byste měli přepnout na režim inodb-na-stůl pomocí <code>innodb\_file\_per\_table</code>.</p> <p>jedním ze způsobů, jak toho dosáhnout, by bylo mít náladové desky (více informací zde: <a href="http://www.viget.com/inspire/getting-moody/">http://www.viget.com/inspire/getting-moody/</a> ), zobrazující barevné palety, typografie, snímky, v podstatě cokoli souvisí s webem.</p> <p>vyzkoušejte <a href="http://www.vanheusden.com/multitail/"><strong> vícesměrný </strong></a> . toto je übergeneralizace <code>tail -f</code>. můžete sledovat více souborů v samostatných oknech, zvýrazňovat řádky podle jejich obsahu a další.</p><pre><code>multitail -c /path/to/log </code></pre><p>barvy jsou konfigurovatelné. pokud pro vás výchozí barevné schéma nefunguje, napište vlastní do konfiguračního souboru. například volejte <code>multitail -cs amir\_log /path/to/log</code> s následujícím <code>~/.multitailrc</code>:</p><pre><code>colorscheme:amir\_log cs\_re:green:info cs\_re:red:severe </code></pre><p>dalším řešením, pokud jste na serveru, kde není vhodné instalovat jiné než <strong> standardní </strong> nástroje, je kombinace <code>tail -f</code> se sed nebo awk pro přidání kontrolních sekvencí výběru barev. to vyžaduje <code>tail -f</code> neprodleně vyprázdnit svůj standardní výstup, i když jeho standardní výstup je potrubí, nevím, jestli to všechny implementace dělají.</p><pre><code>tail -f /path/to/log | awk ' /info/ {print "\033[32m" $0 "\033[39m"} /severe/ {print "\033[31m" $0 "\033[39m"} ' </code></pre><p>nebo s <a href="https://www.gnu.org/software/sed/manual/sed.html">sed</a> </p><pre><code>tail -f /path/to/log | sed --unbuffered \ -e 's/\(.*info.*\)/\o033[32m\1\o033[39m/' \ -e 's/\(.*severe.*\)/\o033[31m\1\o033[39m/' </code></pre><p>pokud vaše sed není gnu sed, nahraďte <code>\o033</code> doslovným únikovým znakem a odeberte <code>--unbuffered</code>.</p><p>další možností je spustit <code>tail -f</code> v <strong> emacs </strong> shell buffer a použití emacsových syntaktických barvicích schopností.</p> <p> <a href="http://www.chrisharrison.net/projects/progressbars/progbarharrison.pdf">tento článek</a> diskutuje vliv různých pruhů relativního pokroku, které se nelineárně zvyšují se skutečným pokrokem:</p><blockquote> <p>naše výsledky naznačují, že uživatelé jsou na začátku operace nejvíce ochotni tolerovat negativní chování (např. stání a nekonzistentní postup). proto mohou být fáze procesu uspořádány tak, že pomalejší nebo variabilní operace jsou dokončeny jako první.</p> </blockquote><p>(„přehodnocení ukazatele pokroku“, chris harrison et.al.)</p> Spustíte-li se `app.debug = True`a sloužit multimediální soubory (obrázky, CSS, JS atd) z baňky, ale také počítají jako plné žádosti. Pokud tomu tak není, pak prosím poskytnout nějaké další informace o nastavení. <p> <a href="http://jd.benow.ca/">jd-gui</a> je v současné době nejlepší dekompilátor. dokáže zvládnout novější funkce v javě ve srovnání s jad.</p>