o’log

Archive for the ‘Inżynieria oprogramowania’ Category

Refleksja po tym wykopie. Oryginalna wersja tutaj.

Na dzisiaj przygotowałem zagadkę:
<ns2:element
     xmlns="http://orb.net.pl/ns/namespace1"
     xmlns:ns2="http://orb.net.pl/ns/namespace2"
     atrybut="i'm so confusing"
/>
Pytanie brzmi: do jakiej przestrzeni nazw należy atrybut?

a) do http://orb.net.pl/ns/namespace1, gdyż jest to domyślna przestrzeń nazw w tym kontekście

b) do http://orb.net.pl/ns/namespace2, gdyż jest to przestrzeń nazw elementu, do którego należy atrybut

c) do żadnej… bo tak

W HTML-u były znaczniki <map> oraz <area> które pozwalały tworzyć linki we fragmentach obrazka. Mechanizm ten nie satysfakcjonował specjalnie ludzi, którzy rozumieją sens separacji treści od prezentacji, dlatego wymyśla się różne sposoby, aby analogiczny rezultat osiągnąć za pomocą samego tylko CSS.

Oto, jak zrealizowałem mapkę z propozycjami wakacyjnymi na stronie Xaverianum.

Zacznijmy od kodu XHTML:

<h1 id="homepage-map">A co z wakacjami?</h1>
<ul id="homepage-map">
 <li id="jdm">
  <a href="/wakacje/jdm" title="Jubileuszowe X Jezuickie Dni Młodzieży (JDM) w Świętej Lipce na Mazurach">
   <strong>Jezuickie Dni Młodzieży</strong>
   <small>w Świętej Lipce</small>
   <span></span>
  </a>
 </li>
 <li id="pielgrzymka">
  <a href="/wakacje/pielgrzymka" title="Pielgrzymka parafialna (pomarańczowa trójka)">
   <strong>Pielgrzymka</strong>
   <small>na Jasną Górę</small>
   <span></span>
  </a>
 </li>
 <li id="bialy">
  <a href="/wakacje/bialy" title="26. obóz adaptacyjny duszpasterstw akademickich Wrocławia i Opola w Białym Dunajcu w Tatrach">
   <strong>Obóz adaptacyjny</strong>
   <small>w Białym Dunajcu</small>
   <span></span>
  </a>
 </li>
</ul>

Mamy zatem zwykłą listę zawierającą linki, ze zwykłymi tekstami. Jedyne, co tutaj szczególne, to pusty znacznik <span/> – w idealnym świecie niepotrzebny, zaś w świecie wciąż zamieszkałym przez Internet Explorera 7 i starsze – konieczne, aby osiągnąć zamierzony cel.

W tle listy wstawmy obrazek z mapą Polski, używając atrybutu padding przesuńmy napisy, żeby jej nie zasłaniały i – uwaga – włączmy pozycjonowanie relatywne (przyda się za chwilę).

ul#homepage-map {
position: relative;
margin: 0; padding: 140px 0 0 0;
background: url(../images/homepage-map.png) no-repeat left top;
height: 460px;
}

Elementom listy <li/> ustawmy ładne tła.

#jdm {
background: url(../images/jdm-bg-hover.png) no-repeat;
}

Podobnie można ustawić tła linkom (które mają wyświetlanie blokowe i wypełniają cały obszar <li/>).

#jdm a {
background: url(../images/jdm-bg.png) no-repeat;
}

Teraz pierwsze czary-mary: Tło pod <li/> będzie tym “podświetlonym”, zaś tło pod <a/> – tym “niepodświetlonym”. Jesli dodamy teraz

#jdm a:hover {
background: none;
color: #503830;
}

to po najechaniu myszką, tło pod <a/> będzie znikać, ozsłaniając tło pod <li/>. Dzięki tej prostej sztuczce – przeglądarki pobierać będą oba obrazki od razu. Gdybyśmy ustawiali “zwyczajnie” – jedno tło dla a, a drugie dla a:hover, te drugie pobrałoby się dopiero w momencie wskazania myszką linka i przez to nie wyświetliło natychmiast.

Przejdźmy jednak do istoty zagadnienia. Tajemniczemu elementowi <span/> nadajmy pozycję absolutną i ustawmy go we właściwym miejscu mapki:

ul#homepage-map span {
display: block;
position: absolute;
cursor: pointer;
}
#jdm span {
left: 375px;
top: 160px;
width: 120px;
height: 140px;
}

Zwróć teraz uwagę, drogi czytelniku, względem czego ten span będzie się pozycjonował. Otóż, względem najbliższego przodka, który ma pozycjonowanie relatywne lub absolutne. Zarówno <a/>, jak i <li/> mają pozycjonowanie statyczne, a więc szukając punktu odniesienia, <span/> trafi na <ul/>.

Ot, cała filozofia. Działający przykład tego rozwiązania znajdziecie na stronie promującej Jezuickie Dni Młodzieży, na które – swoją drogą – serdecznie zapraszam.

Na koniec nie przetestowana idea: teoretycznie, można się pozbyć tego elementu <span/>, który zaśmieca kod i zamiast niego zastosować pseudoelement a::after. Gdyby tylko IE7 zniknęło z rynku…

W menu głównym comprendo.info pojawiła się nowa pozycja: Okładki. Jest to generator szablonu origami pozwalający poskładać elegancją okładkę na płytę CD z kartki A4. Wpisujemy autora i tytuły, drukujemy wygenerowany plik PDF i postępujemy wg. zamieszczonego instruktażu wideo.

Do generowania szablonu wykorzystałem TCPDF.

Przypuśćmy że mamy zdarzenie

public event EventHandler<EventArgs> Bang;

Aby je wywołać, wystarczy napisać Bang(this, EventArgs.Empty);

Nie… Jeśli do zdarzenia nie jest podpięta żadna procedura obsługi tegoż, otrzymamy NullReferenceExcepion.

A zatem if (Bang != null) Bang(this, EventArgs.Empty);

Nie… Read the rest of this entry »

Od mniej więcej roku jako budzika używam komputera. A dokładniej programu WakeupOnStandBy. Jest to mały programik, który potrafi wybudzić komputer ze stanu uśpienia bądź hibernacji (to drugie nie na każdym komputerze) i uruchomić zadany program. Np. odtwarzacz multimedialny. Aplikacja ma bardzo dużo opcji co daje jej wielką uniwersalność. Ale z drugiej strony, ja potrzebowałem tylko budzika, a nie kombajnu.

W końcu ten nadmiar przycisków, checkboksów, pól edycyjnych mnie zirytował i postanowiłem napisać sobie budzik samemu. Taki, który będzie robił dokładnie to, czego potrzebuję – budził mnie – i nic więcej.

Aplikacja jest banalnie prosta: na górze okna mamy TimePicker z biblioteki AvalonControlsLibrary w który wprowadzamy pożądaną godzinę budzenia. Aplikacja domyślnie ustawia to pole na za 8 godzin i 10 minut. 8 godzin, bo tyle snu potrzebuje człowiek, a te 10 minut to zapas na jakieś czynności wykonywane tuż przed snem, typu gaszenie świateł, wyłączanie różnych rzeczy, modlitwa, kładzenie się, zasypianie… Pod godziną jest wielki przycisk z budzikiem – wystarczy go kliknąć i można uśpić komputer. O zadanej godzinie komputer sam się obudzi i zagra utwór, którego wybór umożliwia drugi przycisk. Wybór jest zapamiętywany w pliku konfiguracyjnym, więc nie trzeba używać tego przycisku za każdym razem.

Jak to w ogóle działa? Otóż – znów musiałem skorzystać z API Windows. Tym razem potrzebne są funkcje:

[DllImport("kernel32.dll")]
static extern IntPtr CreateWaitableTimer(IntPtr lpTimerAttributes,bool bManualReset, string lpTimerName);
[DllImport("kernel32.dll")]
static extern bool SetWaitableTimer(IntPtr hTimer, [In] ref long pDueTime, int lPeriod, IntPtr pfnCompletionRoutine, IntPtr lpArgToCompletionRoutine, bool fResume);
[DllImport("kernel32.dll")]
static extern bool CancelWaitableTimer(IntPtr hTimer);
[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
static extern Int32 WaitForSingleObject(IntPtr handle, uint milliseconds);
[DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool CloseHandle(IntPtr hObject);

Uwaga: Funkcja SetWaitableTimer przyjmuje parametr czasu w formacie FILETIME. Obiekt typu DateTime można skonwertować do tego formatu używając metody ToFileTimeUtc().

Program przeznaczony dla systemu Windows Vista z .NET Framework 3.5 (używa klasy GlassWindow z poprzedniego postu).

Download:
Budzik
Budzik – kody źródłowe

PS: Zanim zaufasz budzikowi, upewnij się, czy twój komputer daje się programowo wybudzić z hibernacji. Jak nie, to go na noc tylko usypiaj i upewnij się, że nie zahibernuje się sam.

PPS: Nie biorę odpowiedzialności za szkody wywołane zaspaniem.

Windows Vista udziwnił troszeczkę konstrukcję okna wprowadzając półprzezroczystą część nazywaną Glass (szkło). Jest to ewidentnie wodotrysk i trochę dziwi mnie, dlaczego wprowadzono do API funkcje, które mogą okazać się tylko chwilową modą, która zniknie wraz z nastepną wersją systemu.

No dobrze, w Windows 7 dalej będzie ten wodotrysk, więc skoro już jest, to warto może spróbować go użyć (byle nie nadużyć). Nie oszukujmy się – ludzie lubią wodotryski.

WPF nie daje bezpośredniej możliwości operowania na szkle – potrzebujemy wywołać funkcję API DwmExtendFrameIntoClientArea przyjmującą jako argument uchwyt okna i strukturę MARGINS. A może by tak postarać się trochę i utworzyć DependencyProperty - animowalną, bindowalną i elegancką (na tyle, na ile DependencyProperty można nazywać elegancką) właściwość pozwalającą regulować szklany obszar okna?

Proponuję zrobić to tak:

using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media;

namespace WpfExperiments
{
    public class GlassWindow : Window
    {
        struct MARGINS
        {
            public MARGINS(Thickness t)
            {
                Left = (int)t.Left;
                Right = (int)t.Right;
                Top = (int)t.Top;
                Bottom = (int)t.Bottom;
            }
            public int Left;
            public int Right;
            public int Top;
            public int Bottom;
        }

        [DllImport("dwmapi.dll", PreserveSig = false)]
        static extern void DwmExtendFrameIntoClientArea(IntPtr hwnd, ref MARGINS margins);

        [DllImport("dwmapi.dll", PreserveSig = false)]
        static extern bool DwmIsCompositionEnabled();

        public Thickness GlassFrame
        {
            get { return (Thickness)GetValue(GlassFrameProperty); }
            set { SetValue(GlassFrameProperty, value); }
        }
        public static readonly DependencyProperty GlassFrameProperty =
            DependencyProperty.Register("GlassFrame", typeof(Thickness), typeof(GlassWindow), new UIPropertyMetadata(new Thickness(0, 0, 0, 0), new PropertyChangedCallback(GlassFrameChangedProperty)));

        private static void GlassFrameChangedProperty(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            UpdateGlassFrame((Window)d, (Thickness)e.NewValue);
        }

        private static void UpdateGlassFrame(Window win, Thickness t)
        {
            if (!DwmIsCompositionEnabled())
            {
                return;
            }

            IntPtr hwnd = new WindowInteropHelper(win).Handle;
            if (hwnd == IntPtr.Zero)
            {
                return;
            }

            win.Background = Brushes.Transparent;
            HwndSource.FromHwnd(hwnd).CompositionTarget.BackgroundColor = Colors.Transparent;

            MARGINS margins = new MARGINS(t);
            DwmExtendFrameIntoClientArea(hwnd, ref margins);
        }

        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);
            UpdateGlassFrame(this, GlassFrame);
        }
    }
}

Teraz – zamiast tworzyć okna na bazie klasy Window, możemy użyć klasy GlassWindow posiadającej właściwość GlassFrame typu Thickness, którą możemy się posługiwać jak każdą inną DependencyProperty.

Ustawiając dodatnie wartości dla GlassFrame, możemy regulować grubość szklaj ramki. Jeśli ustawimy wartości ujemne – całe okno zrobi się szklane.

W ramach eksperymentów z LINQ, trochę z WPF, napisałem programik do wyznaczania modelu regresji liniowej. Program wczytuje dane empiryczne z pliku CSV (w pierwszej kolumnie powinny być wartości zmiennej objaśnianej, w następnych – objaśniających; powinno być przynajmniej 10 wierszy), następnie dobiera zmienne metodą Bartosiewicz (grafową) aby na końcu wypluć równanie modelu.

Może się przyda jakiemuś studentowi na zaliczenie… Zwłaszcza, że utwór przekazuję do domeny publicznej.

Download

PS: Nie gwarantuję, że program działa w pełni poprawnie.

Wśród młodych użytkowników Internetu rozpowszechnił się szkodliwy mem pisania w NiEcZyTelNy sPosooP. Irytuje to praktycznie wszystkich – prócz tych, którzy tak piszą. Czy możemy coś na to poradzić? Oprócz ciągłego krytykowania? Ależ tak. Mem jest bardzo prymitywny, stąd da się zwalczyć równie prymitywnym algorytmem.

Zastanówmy się chwilę, czym różni się normalny tekst od PoKeMoNoWeGo? Ilością wielkich liter. W normalnych tekstach, Wielkich liter jest relatywnie mało. Pokemony zaś piszą wielką mniej więcej co drugą, co trzecią literę. Jakiż problem policzyć?

Istnieje też mutacja memu pokemonowego, zwana l33t. Różnice są dwie:

• Umysłowi opanowanemu przez mem l33t wydaje się, że fakt tej infekcji wiąże się z jego elitarnością
• Zamiast nadmiaru wielkich liter, mamy nadmiar cyfr i znaków niealfanumerycznych.

W swoim comprendo.info zastosowałem funkcję walidacyjną, która stara się wyłapać ofiary obu wersji memu. Webmasterze! Użyj jej (lub podobnej) dla dobra Internetu!

function killPokemon($input)
{
    $all = strlen($input);
    $upper = 0;
    $nonchar = 0;
    for($i = 0; $i < $all; $i++)
    {
        //Spacje zignoruj.
        if($input{i} == ' ')
        {
            $all--;
            continue;
        }
        $u = strtoupper($input{$i});
        $l = strtolower($input{$i});
        //Znaki niebędące literami pozostaja niezmienione przez funkcje strupper i strlower.
        if($u == $l)
        {
            $nonchar++;
        }
        //Litery niezmienione przez strtoupper są wielkie.
        else if($input{$i} == $u)
        {
            $upper++;
        }
    }
    //Zwróć true, jeśli tekst zachowuje normy ilości wielkich liter i znaczków. 
    //Progi dobrałem eksperymentalnie.
    return ($upper/$all < 0.12) && ($nonchar/$all < 0.22);
}

Kod przekazuję do domeny publicznej. Można go dowolnie używać, nawet bez podawania autora.

Przypuszczam, że kod nie jest optymalny. Ale grunt, że działa.

PS: Mówią, że nawet sztuczna inteligencja nie pokona naturalnej głupoty. To prawda – np. ta funkcja radzi sobie z głupim sposobem pisania, ale wobec głupiej treści jest już bezradna.