GraphStudioNext update 0.7 coming soon

I know it is a long time since the last update on this blog, but hey, who cares? To get more for you to read here, I will start a series of posts about DirectShow, COM and GraphStudioNext! That’s what I know a lot about, so why not also write about it.

So lets start with my Open Source project GraphStudioNext. Thanks to Mike, the second “owner” of the project and Roman the Godfather of DirectShow (http://alax.info/blog/) we have implemented a lot of cool new features since the last official update *cough* a year ago *cough*. Here are some of my favorites I use in support and development to analyze DirectShow problems:

Show registered file and protocol handlers: that’s an absolute must have. If you try to render a file in DirectShow, the system looks for registered protocol-handlers and especially file-handlers. File-handlers for an extension are simple to find and fix. But if you have an old and buggy Haali Media Splitter registration, which is still there after you deinstalled it, that’s an challenge! With this new features you can also see the registered Byte-handlers for a file. Here you can see, that the filter is also registered for a byte pattern, or maybe nearly all byte pattern.

Different icon for 64bit version: because I work heavily in both worlds, 32bit and 64bit, I have pinned two GraphStudioNext’s in my Windows 7/8 Taskbar (also now possible with the coming release). And now I can see which version I need to start. The normal 32bit version or the version with the 64 in the Icon.

New file-extension .grfx for our XML-Filtergraphs: to easier open a saved filtergraph, we now use an own file-extension for it. Like Word/Excel 2003 we just added an ‘x’ to our GraphFile (.grf) implementation. The program registers itself for this extension with the current program location.

Start with RemoteGraph from DirectShowSpy: we now store the current location of the program-file in the registry. And GraphStudioNext can be started with the name of a RemoteGraph. So you can now open the program directly from the running graphs overview in DirectShowSpy. Here you can find Romans post about this feature.

(Un-)Register Filter without restart the program as Admin: that is something I needed for a long time. I always forgot to start the program as admin to change the merit of a filter or unregister the filter. Now this is no problem, because these actions are redirected to regsvr32.exe or reg.exe and you see their admin question.

Scan for CLSIDs in the DLL: for DirectShow filter-developers this is a nice little feature. In the last version it was already possible to load a filter from a file without registering it, but you needed to know the CLSID of the filter. Thanks to this new feature you can just scan the dll-file for all CLSIDs in it! Oh and by the way, you can scan nearly all COM-DLL-files. 😉

Change DbgLog settings and show Logfile: this is also a feature especially for DirectShow filter-developers like me. If you use the DirectShow BaseClasses for your logging, you can now change the logging settings directly from GraphStudioNext without the need to remember the registry location for it. And that’s not all, if you set a log-file as logging target, you can view this logfile directly in the program (in Filter-Properties-Dialog).

There are also a ton of other additions and fixes to the program, like AAC support for the PSI-Config-Filter or sizeable property pages, but that’s to much to list them all.

Stay on for more posts coming soon.

Juhu, 1.000+ Downloads von Tendoid (lite) im Android Market!

Nach fast genau 5 Monaten hat meine erste Android-App endlich über 1.000 Downloads im Android Market. Das Beste ist, von den 1.000 Downloads sind sogar noch 1/4 aktiv. Hier gibt’s den Beweis als Screenshot dazu:

Bei Tendoid handelt es sich um ein Mahjong Clone, den ich bereits als normales PC-Programm umgesetzt hatte und später dann für Android. Eine genaue Beschreibung der (Leidens-)Geschichte des Programmes, sowie einen Einblick in die Entwicklung und die “Vermarktung” des Programmes gibt es in einem der folgenden Blog-Posts.

Und für alle die es interessiert, gibt es hier noch die ganze Statistik für die App (erweitert um ein paar Anmerkungen):

Application.OnIdle equivalent for WPF

If you need an alternativ to the WinForms Application.OnIdle event in WPF you can use the DispatcherTimer.

DispatcherTimer timer = new DispatcherTimer(DispatcherPriority.ApplicationIdle);
timer.Tick += (s, e) => {
    // Do something
};
timer.Start();

Do you only need the function executet once on idle you use BeginInvoke with Priority Idle.

Dispatcher.CurrentDispatcher.BeginInvoke((Action)(() => {
    // Do something
}), DispatcherPriority.ApplicationIdle);

If you don’t like the lambda-style you can also write this:

Dispatcher.CurrentDispatcher.BeginInvoke((Action)doSomething, DispatcherPriority.ApplicationIdle);

Here doSomething needs to be a void function without parameters.

Horziontal Rule in WinForms

Sometime you need a horizontal rule in your WinForms dialog, like the HTML <hr> element. In MFC you have done it with a Static and in WinForms you do it with the equivalent to it, the Lable. First you need to empty the Text of the Label and set the BorderStyle to “Fixed3D”. To set a Witdh or Hight you need to set AutoSize to false. Then you set a Height of 2 and a Width of e.g. 100 and see you have a horizontal rule. If you set the Height to 3 or 4, you can also change the BackColor and get a colorfull version of your horizontal rule. The same applies to a vertical rule, you only swap Width and Height.

Podzieh Teil 1: Einlesen eines RSS-Feeds für Podcasts

So nun wird es ernst. Willkommen zum ersten Teil des Entwicklungstagebuches für meinen Podcatcher “Podzieh”. Die Anforderungen an das Programm habe ich im letzten Post bereits aufgeführt. Ich werde hier, in hoffentlich regelmäßigen Abständen, über aktuelle Punkte der Implementierung des Programmes schreiben. Und ich würde sagen, beginnen wir mal mit dem wichtigsten Punkt für einen Podcatcher, das Abrufen und Einlesen des RSS-Feeds.

Beispiele für RSS-Feeds habe ich im Post “Podcasts für Entwickler und für nebenbei” genügend geliefert, diese Feeds dienen mir als Referenz für mein Programm. Ich hoffe damit decke ich den Großteil der Möglichkeiten ab. In meinem Programm lege ich mich auf RSS-Feeds der Version 2.0 fest, da alle Feeds die ich bisher gefunden haben auch diese Version hatten. Einen guten Einstieg in den Aufbau eines RSS bietet w3schools.com/rss. Beim RSS Format handelt es sich im Grunde genommen nur um ein genau definiertes XML-Schema. Leider reicht manchen diese Vordefinierte Struktur nicht aus, und so kommen dann Erweiterungen, wie zum Beispiel die für iTunes, dazu. Da es sich einfach nur um XML handelt, kann ich solch einen Feed mit den XML Klassen des dotNet Frameworks einlesen. Um die Erweiterungen zu Nutzen muss ich allerdings beim Analysieren des XML auf die Xml-Namespaces achten. Achja noch kurz zu Anmerkung, das Programm wird mit dem dotNet Framework 4 Client Profile entwickelt.

Zur Verarbeitung des RSS-Feeds müssen nur zwei Klassen angelegt werden. Eine für den “Channel”, dieser Beschreibt den Podcast im allgemeinen, und eine Klasse für das “Item”. Das Item stellt eine Episode im Podcast dar und kommt somit mehrfach als Kindelement des Channel vor. Damit keine fehlerhaften Objekte zustande kommen können, kann eine Instanz der Klassen nur über eine Factory-Methode erstellt werden. So kann ich zum Beispiel beeinflussen, was passiert wenn es sich nicht um einen RSS-Feed mit Version 2.0 handelt. Eingelesen wird das XML mit LINQ und der XDocument Klasse. Eine wirklich schöne Hilfe beim einlesen des XML ist die automatische Konvertierung des Inhaltes eines XElement bzw. XAttribute. Man muss nur den entsprechenden cast davor schreiben. Wenn man das ganz dann auch noch mit Nullable-Typen verbindet kann man sich etliche if Abfragen sparen.

public class Channel
{
    #region Namespaces

    public static XNamespace NsItunes = XNamespace.Get("http://www.itunes.com/dtds/podcast-1.0.dtd");
    public static XNamespace NsMedia = XNamespace.Get("http://search.yahoo.com/mrss/");

    #endregion

    #region Properties

    public string Title { get; protected set; }
    public string Description { get; protected set; }
    public string URL { get; protected set; }
    public IEnumerable<Item> Items { get; protected set; }

    public string LocalFolder { get; set; }

    #endregion

    #region Init

    protected Channel() { }

    public static Channel LoadFromFeed(string url)
    {
        XDocument doc = XDocument.Load(url);
        if(doc == null) return null;
        XElement rss = doc.Element("rss");
        if (rss == null || (string)rss.Attribute("version") != "2.0")
            return null;

        XElement channel = rss.Element("channel");
        if (channel == null) return null;

        Channel c = new Channel()
        {
            URL = url,
            Title = (string)channel.Element("title"),
            Description = (string)channel.Element("description")
        };

        c.Items = channel.Elements("item")
                            .Select(i => Item.LoadFromXml(i))
                            .Where(i => !String.IsNullOrEmpty(i.Download) && !String.IsNullOrEmpty(i.Title));

        return c;
    }

    #endregion
}

Die Liste mit den Items erstelle ich mit Hilfe der LINQ Extension Methoden. Mit “Elements()” geh ich alle Items durch. Auf diese Enumeration wird ein “Select” angewedet, welches aus den XML-Items eine Item-Instanz meiner Klasse macht. Im Anschluss daran, Filter ich gleich die mit raus, bei denen ich keinen Download gefunden habe.

public class Item
{
    #region Properties

    public string Title { get; protected set; }
    public string Description { get; protected set; }
    public string Guid { get; protected set; }
    public string Author { get; protected set; }
    public string Download { get; protected set; }
    public long? DownloadSize { get; protected set; }

    public DateTime? PubDate { get; protected set; }

    public string LocalFile { get; set; }

    #endregion

    #region Init

    protected Item() { }

    public static Item LoadFromXml(XElement el)
    {
        Item i = new Item()
        {
            Title = (string)el.Element("title"),
            Description = (string)el.Element("description"),
            Guid = (string)el.Element("guid"),
            Author = (string)el.Element("author")
        };

        if (String.IsNullOrEmpty(i.Guid))
            i.Guid = (string)el.Element("link");

        if(el.Element("pubDate") != null)
            i.PubDate = (DateTime?)el.Element("pubDate");

        if (i.Description == String.Empty)
        {   // wenn in description nichts drin steht, ist vieleicht im itunes-tag summary was drin
            i.Description = (string)el.Element(Channel.NsItunes + "summary");
        }

        if (el.Element("enclosure") != null)
        {
            i.Download = (string)el.Element("enclosure").Attribute("url");
            i.DownloadSize = (long?)el.Element("enclosure").Attribute("length");
            if (i.DownloadSize.HasValue && i.DownloadSize.Value == 0)
                i.DownloadSize = null;
        }

        if(String.IsNullOrEmpty(i.Download) || !i.DownloadSize.HasValue)
        {   // wenn in enclosure nichts steht, steht das vieleicht in einem media:content-tag
            XElement elMedia = el.Element(Channel.NsMedia + "content");
            if (elMedia != null && elMedia.Attribute("url") != null)
            {
                i.Download = (string)elMedia.Attribute("url");
                i.DownloadSize = (long?)elMedia.Attribute("fileSize");
                if (i.DownloadSize.HasValue && i.DownloadSize.Value == 0)
                    i.DownloadSize = null;
            }
        }

        return i;
    }

    #endregion
}

Wenn ich beim Einlesen eines Items keinen Download finde, versuche ich es mit dem Element media:content. Hier steht im Grunde das gleiche drin wie im enclosure-Element. Die Guid wird verwendet um die Episode eindeutig zu Identifizieren und später mit einer Datenbank abzugleichen. Die Properties “LocalFolder” und “LocalFile” habe ich angelegt um hier nach dem einlesen des Feeds, den Pfad zur lokalen Instanz einzutragen. Mehr dazu in einem späteren Post.

Mein eigener Podcatcher: Podzieh

Wie im letzten Post schon angedeutet suche ich zur Zeit nach einem guten Tool zur Verwaltung meiner Podcast-Downloads und –Feeds. Alle Programme die ich bis jetzt getestet habe, sind mir einfach zu überfrachtet oder zu Kompliziert. Aus diesem Grund habe ich mich dazu entschlossen ein eigenes kleines Programm dafür zu entwickeln. Schließlich bin ich nicht umsonst Softwareentwickler geworden .

 

Im allgemeinen wird die Gruppe von solchen Programmen als Podcatcher bezeichnet. Solch einem Programm wird Üblicherweise der RSS Feed eines Podcasts übergeben und es zeigt dann die verfügbaren Downloads an und lädt sie bei Bedarf herunter. Genau aus diesem Verhalten habe ich den Namen für mein kleines Programm abgeleitet. Ich wollte es zwar erst “Podzblitz” nennen, dass war mir dann aber doch zu abgedroschen und nicht beschreibend genug. Darum soll es jetzt “Podzieh” heißen, sowie PODcast und aus dem Netz ZIEHen.

 

So und um auch gleich einen Einstieg zu haben, beginnen wir doch mal mit der Anforderungsanalyse. Was soll das Programm denn können? Für mich am wichtigsten sind eigentlich folgende Punkte:

• Verwaltung von Podcast-Feeds, das Umfasst folgende Kriterien
  • Eingabe von RSS URLs
  • Abrufen des RSS Feeds
  • Überprüfen auf neue Einträge
• Herunterladen von Podcast-Folgen
  • Eine oder mehrere Folgen auswählbar zum herunterladen
  • Download im Hintergrund
  • Fortschrittsanzeige
  • Speicherung in einer eigenen Ordnerstruktur, zum Beispiel jeder Feed in einem eigenen Ordner
  • ggf. fortsetzen von Downloads
• Markieren der Folgen
  • als gehört Kennzeichnen
  • Bewerten
  • ggf. automatisches löschen, wenn Platz gespart werden soll
• Abspielen
  • ggf. auch schon abspielen, wenn sie noch nicht fertig heruntergeladen wurde!
• Konvertieren ins AAC Format
  • zur Platzsparenden Archivierung oder um den Speicherplatz des Smartphone zu schonen
  • natürlich auch im Hintergrund
  • frei Konfigurierbar
  • vorgegebene (empfohlene) Profile
• Übertagen auf ein (Android-)Smartphone per WLAN

So das sind jetzt erst mal alle Punkte die mir Einfallen. Sicher gäbe es auch noch ein paar Features mehr die man in so ein Programm stecken könnte, aber man sollte es auch nicht übertreiben. Denn jetzt kommen ja noch die Nicht-Funktionalen Anforderungen, die die ganze Sache erst richtig interessant machen.

• Natürlich soll das Programm eine optisch ansprechende Oberfläche haben
• es soll möglichst Idiotensicher sein; der Nutzer soll so viel wie möglich mit dem Programm machen können und so wenig wie nötig dafür tun müssen
• Beachtung des CleanCodeDeveloper Wertesystems bei der Entwicklung
• und das Ganze soll Open-Source sein

So das ist jetzt erst mal ein ganz schöner Brocken Arbeit der da vor mir liegt. Ich hoffe ich kann alle Punkte so umsetzen wie ich mir das vorstelle. Ich werde versuchen bei der Entwicklung immer hier auf dem Blog zu schreiben und auf jeden Funktionspunkt näher einzugehen. Wenn Ihr noch weitere Ideen habt, was unbedingt in so ein Programm gehört, könnt Ihr mir gern einen Kommentar da lassen, bzw. könnt Ihr auch einfach schreiben was Ihr von der Idee haltet.

Podcasts für Entwickler und für nebenbei

Wenn man mal wieder den Abwasch machen muss, etwas im Garten arbeitet oder einfach nur mit der Bahn fährt, mit einem Podcast in den Ohren geht das Alles viel leichter. Wenn ich mal gerade nicht am Entwickeln und Programmieren bin, tu ich durch das Podcast hören etwas um mich weiterzubilden und um mich zu informieren. Wenn ich ganz ehrlich bin, ist es aber vor allem als Unterhaltung gedacht. Da ich mein Handy/Smartphone immer dabei habe, lade ich mir dort regelmäßig die neuesten Episoden von verschiedenen Podcasts drauf.

Zum Podcast hören gekommen bin ich erst vor kurzem. Irgend wie ist die ganze Podcast-Mania vor ein paar Jahren ganz an mir vorbeigezogen, ohne das ich dem etwas abgewinnen konnte. Gepackt hat mich das Podcast-Fieber erst mit den wirklich gut und professionell gemachten Podcasts von gameone.de. Da ich die meisten der Redakteure schon seit Giga-Zeiten aus dem Fernsehen kenne, ist das hören der Episoden ganz angenehm.  Vor allem treffen aber die Retro und Kopfkino Podcasts genau ins Schwarze bei mir. In den Retro-Podcasts geht es vor allem um Spiele aus der guten alten Zeit, also genau da wo ich auch gespielt habe (SNES und Co.). Und in den Kopfkino-Podcasts werden Filme bzw. Filmreihen besprochen. Absolutes Highlight war hier natürlich der Livecast zur Oscar-Verleihung 2011. Da mein Sohn natürlich genau in dieser Nacht um 2 Uhr aufgewacht ist und nicht mehr schlafen wollte, habe ich mir tatsächlich die Oscar-Verleihung Live im Fernsehen angesehen. Ohne den Livecast und die Kommentare der gameone Redakteure hätte ich diese langweilige Verleihung wohl nicht durchgestanden.

Aber das war nur der erste von zwei Podcasts die mich zu einem Fan dieses Mediums haben werde lassen. Der gameone Podcast ist natürlich nur etwas zur Unterhaltung. Richtig die Augen oder besser gesagt Ohren geöffnet hat mir dann der SoftwareArchitekTOUR-Podcast von heise.de/developer. Hier geht es um mein Lieblingsthema, die Softwareentwicklung. Naja eigentlich nicht ganz um die Softwareentwicklung, sondern wie der Name schon sagt um Softwarearchitektur. Besprochen werden Vorgehensmodelle, Designschwerpunkte, Pattern und aktuelle Entwicklungen wie NoSQL und Cloud Computing.

So genug geredet, es wird Zeit sich etwas anzuhören. Hier nun meine Liste mit Podcasts die ich regelmäßig höre, bzw. auf die ich gerade erst aufmerksam geworden bin.

• gameone.de Plauschangriff  | website | feed
• SoftwareArchitekTOUR-Podcast | website | feed
• pentacast (Podcast des c3d2) | website | feed
• Technikwürze Podcast | website | feed
• Working Draft Podcast | website | feed
• Spieleveteranen | website | feed

Und hier noch ein paar interessante  Englische Podcasts:

• Experimental Game Dev Podcast Show | website | feed
• hanselminutes | website | feed
• This Developers Life | website | feed

Natürlich gibt es noch wesentlich mehr englischsprachige Podcasts, es macht nur keinen Sinn die hier alle aufzuzählen.

Da es mit der Zeit ganz schön unübersichtlich wird mit so vielen unterschiedlichen Podcasts und dem ganzen Runtergelade und Angehöre, bin ich zur Zeit noch auf der Suche nach einer guten Software, die das Alles etwas Unterstützt. Ich hab zwar auch schon ein paar Programme ausprobiert, aber so richtig glücklich geworden, bin ich mit keinem. Über Empfehlungen würde ich mich hier freuen. Aber anscheinend muss ich da wohl selber mal ran und mir genau das Programmieren was ich brauch!

ALM mit Redmine, Teil 2

Im ersten Teil hatte ich ja bereits angekündigt, dass ich über unsere Erfahrungen mit Redmine weiter berichten werde. Leider hat sich das Ganze anders entwickelt als gedacht. Da bei uns vornehmlich Outlook zum Einsatz kommt und wir auch alle unsere Kundendaten im Outlook haben, nutzen wir jetzt doch eine Kommerzielle Erweiterung für Outlook um unsere Support-Anfragen zu bearbeiten. Aber nichts des do trotz arbeite ich jetzt erst mal alleine mit Redmine.

Da ich mehrere kleine und große Projekte habe, die ich in Eigenregie plane und Entwickle ist eine gute Aufgabenplanung unerlässlich. Mit Redmine habe ich jetzt endlich ein vernünftiges Werkzeug dafür gefunden. Ich habe mehrere Projekte und Unterprojekte in denen vor allem die drei Tracker “Bug”,  “Feature” und “Anforderung” zum Einsatz kommen. Für Bugs war das ganze ja sowieso gedacht, jetzt kommt der Bugtracker halt zum Einsatz wenn ich selber Fehler finde oder der Kunde mir direkt welche schickt. Im Tracker “Feature” landen Ideen für Erweiterungen unserer Produkte.

Besonders wichtig ist für mich in letzter Zeit der Tracker “Anforderung” geworden. Da es sich hier um konkrete Aufgaben handelt, welche für den Kunden abgearbeitet werden müssen, ist das der Tracker mit den meisten Tickets. Außerdem nutze ich den Tracker dafür, meine Aufwände zu Planen. Ich zerlege die Aufgaben so, dass ich bei Maximal ein bis zwei Tagen, am besten jedoch bei ein bis zwei Stunden rauskomme. Somit kann ich bei einem Angebot ziemlich zuverlässig sagen wie viel Manntage bezahlt werden müssen.

Damit die Planung auch Sinnvoll und Realistisch ist, muss natürlich der tatsächliche Aufwand mit erfasst werden. Erst dadurch ist es möglich die Abschätzungen zu überprüfen und bei neuen Aufgaben genauere Zahlen zu liefern. Damit man nicht ständig auf die Uhr schauen muss wenn man an einer Aufgabe arbeitet, gibt es zum Glück das TimeTracker Plugin. Es zeigt in der rechten oberen Ecke einen Button “Start #xxx” mit dem die Zeiterfassung für die aktuelle Aufgabe begonnen werden kann. Wenn der Timer läuft wird an dieser Stelle immer die aktuell benötigte Zeit angezeigt. Und da es wahrscheinlich vielen so geht wie mir, die beim Arbeiten durch Telefonate oder Sonstiges abgehalten werden, gibt es einen Pause-Button, welcher die Zeitmessung unterbricht. Drück man schließlich auf den Stopp-Button öffnet sich automatisch die Aufwands-Erfassungsmaske, in der die benötigte Zeit, in Stunden umgerechnet, bereits eingetragen ist. Hier kann man nun noch ein Kommentar mit einer Beschreibung der Tätigkeit eingeben und das Ganze als Tätigkeit für die Aufgabe speichern.

Da bei mir der Berg an Papier mit Feature-Wünschen und Anpassungen von unseren Kunden immer weiter gewachsen ist und ich da nicht mehr wirklich durchgesehen habe, wird so etwas jetzt immer eingescannt. Die PDF Datei hänge ich dann an die konkrete Aufgabe oder den Fehler als Anlage mit dran. Somit entfällt das lange Gesuche nach irgendwelchen Blättern mir Designvorgaben und Co. Das gleiche gilt natürlich auch für Dokumente oder Screenshots die ich per Mail erhalten habe. Sollte solch eine Datei mehrere Aufgaben betreffen, gibt es in Redmine die Möglichkeit, Dokumente zu einem Projekt zu speichern. Diesen Dokumenten gibt man einen Namen und eine kurze Beschreibung. Per document#xxx (xxx ist die ID des Dokuments) kann man dann schließlich in der Beschreibung einer Aufgabe oder einem Kommentar auf das Dokument verlinken. Hierbei wird der Ausdruck mit dem Dokumentnamen ersetzt. Es gibt übrigens eine ganze Reihe solcher Ausdrücke , um zwischen Dokumenten, Wiki-Einträgen und anderen Aufgaben zu verlinken. Eine Übersicht dafür liefert die Wiki-Seite von Redmine.

jQuery Tablesorter Pager: Jump to Page

This is my first blog in english, so sorry for any spelling errors.

In one of our projects, we use the great jQuery library. A very cool plugin for jQuery is the tablesorter and the extsion to this, the pager. The only disadvantage of the pager plugin is the missing function “Jump To Page”. You can only display the current page and the page count as one string. So i have modified the code of the pager plugin a little, to add this function.

It is a very simple extension, only two existing functions need to be updated. To identify the input-field for the current page and the div for the pagecount, i added two new properties to the settings: cssPageCurrent and cssPageCount. The first function to update is the constructur. Here i connect to the change-event of the input-field and call the moveToPage function. The second function is named updatePageDisplay. It is responsible to update the number in the currentpage-inputfield if you navigate with the next/prev buttons.

Here are the updated functions:

function updatePageDisplay(c, table) {
    var txt = (c.page + 1) + c.seperator + c.totalPages;
    var pd = $(c.cssPageDisplay, c.container)
    if (pd.is("input"))
        pd.val(txt);
    else
        pd.text(txt);

    var pcur = $(c.cssPageCurrent, c.container)
    if (pcur.is("input"))
        pcur.val(c.page + 1);
    else
        pcur.text(c.page + 1);

    var pcount = $(c.cssPageCount, c.container)
    if (pcount.is("input"))
        pccount.val(c.totalPages);
    else
        pcount.text(c.totalPages);

    $(table).trigger("tableSorterPagerUpdatePageDisplay");
}

this.defaults = {
    size: 10,
    offset: 0,
    page: 0,
    totalRows: 0,
    totalPages: 0,
    container: null,
    cssNext: '.next',
    cssPrev: '.prev',
    cssFirst: '.first',
    cssLast: '.last',
    cssPageDisplay: '.pagedisplay',
    cssPageSize: '.pagesize',
    cssPageCount: '.pagecount',
    cssPageCurrent: '.pagecurrent',
    seperator: "/",
    positionFixed: true,
    appender: this.appender
};

this.construct = function (settings) {

    return this.each(function () {

        ...

        $(config.cssPageCurrent, pager).change(function () {
            var c = table.config;
            var p = $(this).val();

            if (p != c.page + 1) {
                p = parseInt(p) - 1;
                if (p < 0 || isNaN(p)) p = 0;
                else if (p > c.totalPages - 1) p = c.totalPages - 1;

                c.page = p;
                moveToPage(table);
            }

            return false;
        });
    });
};

Here you can download the changed scriptfile: jquery.tablesorter.pager.js

And here is how i used it:

<html>
<head>
    <script type="text/javascript">
        $(document).ready(function () {
            ...
            $(".tblSortable").tablesorter();
            $(".tblSortable").tablesorterPager({ container: $("#pager"), positionFixed: false, size: 30 });
            ...
        });
    </script>
</head>
<body>
    ...
    <div id="pager" align="center">
        <input type="text" name="pagecurrent" class="pagecurrent">
        <span> / </span>
        <span class="pagecount">1</span>
    </div>
    ...   
    <table class="tblSortable">
        ...
    </table>      
</body>
</html>

ALM mit Redmine, Teil 1

Kürzlich war ich auf der Suche nach einem guten Bugtracker, um den Support in unserer Firma etwas zu unterstützen und um so eine Art Wissensdatenbank aufzubauen. Zur Zeit werden bei uns Fehlermeldungen und Probleme von Kunden unserer Produkte vom Support-Mitarbeiter entgegengenommen und so weit geholfen wie möglich. Wenn unser Support-Mitarbeiter nicht mehr weiter weiß, wird das Problem telefonisch oder per E-Mail an den entsprechenden Entwickler dieser Software weitergeleitet. Der bearbeitet dann das Ganze und schickt dem Kunden eine Lösung bzw. verweist ihn auf ein kommendes Update der Software. Es ist natürlich ungünstig für den Entwickler, wenn ähnliche Probleme immer wieder bei ihm auf den Tisch landen und ihn von der eigentlichen Arbeit abhalten.

Um diesen Missstand zu beheben wollen wir jetzt einen Bugtracker einführen welcher den Support-Mitarbeiter bei der Fehlerbehebung unterstützt. Einmal aufgetauchte Fehler oder auch nur Anfragen werden in den Bugtracker eingetragen und kategorisiert. Wenn der Fehler nicht gleich behoben werden kann, kümmert sich der entsprechende Entwickler darum und trägt die Lösung ein bzw. verweist auf die Programmversion, in der der Fehler behoben ist. So weit der Plan jedenfalls!

Bei meiner Suche nach entsprechenden Lösungen bin ich natürlich auf tausende von Systemen und Programme gestoßen. Da das Ganze aber so kostengünstig wie möglich sein soll, blieben nur ein paar wenige Open-Source Programme übrig. Die da wären Bugzilla, Mantis, Trac und schließlich Redmine.

Von den ganzen Programmen hat mir Redmine am besten gefallen. Bugzilla war zwar gut, aber die Installation ist einfach unmöglich. Mantis ist vom Umfang her auch recht gut, aber die Oberfläche sieht einfach altbacken aus. Und Trac schließlich hat keine wirklich zufriedenstellende Multi-Projekt-Unterstützung und eine zu komplizierte Oberfläche. Redmine war mir vorher total unbekannt, aber dank Bitnami und ihren fertigen All-in-one-Installern bzw. ihren fertigen Virtuellen Maschinen konnte ich den Bugtracker ohne Probleme ausprobieren.

Also läuft jetzt bei uns erst mal eine VM mit Ubuntu 10.10, Apache, MySql, Ruby und Redmine zum Testeinsatz. Dank der Weboberfläche war es das schon fast mit der Installation der Software im Unternehmen. Jetzt bracht nur noch jeder Mitarbeiter ein Login und den Link mit der IP der VM und dem Programm. Die Weitere Einrichtung des Programmes sowie unsere Erfahrungen damit, werden in den kommenden Teilen beschrieben.