Will man seine eigenen Vorgänge in Form von Skripts o.ä. regelmäßig ausführen lassen, dann hat man folgende Möglichkeiten.

1. Einfügen eines eigenen Skripts in den existierenden periodic Mechanismus

Abhängig davon, ob der Vorgang täglich, wöchentlich oder monatlich ablaufen soll, gibt es eine dafür vorgefertigte Ablage:
* /etc/periodic/daily – Verzeichnis, welches die täglich auszuführenden Skripts enthält
* /etc/periodic/weekly – Verzeichnis, welches die wöchentlich auszuführenden Skripts enthält
* /etc/periodic/monthly – Verzeichnis, welches die monatlich auszuführenden Skripts enthält

Die Reihenfolge wie die Skripts ausgeführt werden ist über die vorangestellte Zahl definiert. Und die Uhrzeit wann die Skripts gestartet werden, ist über die Konfiguration des periodic Mechanismus definiert. Wie man die Ausführungszeit dieses Dienstes beeinflussen kann, erfährt man hier.

2. Hinzufügen eines eigenen Skripts bzw. Skriptaufrufs in einen vorgefertigten Platzhalter.

Jeweils am Ende eines periodic Ablaufs wird ein vordefiniertes Skript ausgeführt, sofern es existiert.
* /etc/daily.local
* /etc/weekly.local
* /etc/monthly.local

Werden verschiedene Interpreter zur Ausführung der Befehle benötigt, dann kann man aus dieser Datei weitere Skripts aufrufen. Dann sind für den Fall eines Abbruchs jedoch spezielle Vorkehrungen zu treffen.

Anstatt eines Skripts lassen sich auch mehrere oder der Inhalt eines ganzen Verzeichnis ausführen. In diesem Fall kann man in einer der unter 3. erwähnten Dateien die Variablen:
* $daily_local
* $weekly_local
* $monthly_local
überschreiben (z.B. monthly_local=”/usr/local/scripts.monthly/*”).

3. Vorgesehene Ablage aktivieren …

Entsprechend den Anforderungen eigene Konfigurationsvariablen hinterlegen oder vorhandene überschreiben. Dafür sind zwei Dateien vorgesehen:
* /etc/periodic.conf
* /etc/periodic.conf.local
Auch ein Verzeichnis zur Ablage der eigenen Maßnahmen ist schon definiert: /usr/local/etc/periodic in der Variable $local_periodic.
Es wird allerdings vom bestehenden Mechanismus (noch) nicht verwendet.
Bei Bedarf kann man es in einer der beiden o.g. lokalen Konfigurationsdateien anpassen.

Analog zu den 999.local Skripts in den unter 1. aufgeführten Verzeichnissen bspw. 888.local Skripts anlegen, welche die benötigten selbstdefinierten Variable auswerten.

Dieses Tutorial ist für Einsteiger gedacht. Um mitarbeiten zu können benötigen Sie Visual Studio 2010 mit dem Silverlight 4 Add On und Vorkenntnisse in C#. Ich zeige Ihnen hier lediglich eine von vielen Lösungen dieses Problems.

Inhalt

1. Google Weather API
2. Erstellen eines Proxy-Services
3. Klassendiagramm
4. Erstellen der Klassen
5. Erstellen der GUI

Google Weather API

Vorab müssen Sie darüber im Klaren sein, dass die API nicht Dokumentiert ist. Schauen wir uns die API genauer an:

http://www.google.com/ig/api?weather=Stadt.Land&hl=De

Wenn wir den Link genauer betrachten sehen wir, dass er drei Parameter besitzt welche wir verändern können. Hier “Stadt”, “Land” und “De”. Man kann allerdings “Land” weglassen und anstelle einer Stadt deren Postleitzahl eingeben. Mit dem “De” am Ende des Links geben wir an in welcher Sprache uns die Wetterdaten übermittelt werden sollen. Wenn wir den Link nach diesen Angaben bearbeiten sieht er z.B. so aus:

http://www.google.com/ig/api?weather=Berlin.germany&hl=De

Hierbei ist es egal ob man das Land in Englisch oder in Deutsch schreibt.

Beim aufrufen dieses Links wird uns eine XML-Struktur angezeigt die wie folgt aussieht:

Es gibt nur drei unterschiedliche Parts die für uns Interessant sind und zwar:

Nun werfen wir einen näheren Blick auf die drei verschiedenen Parts und suchen uns die Attribute raus die für uns wichtig sind.

1. Gibt uns Stadt und Bundesland.
2. Gibt uns das aktuelle Datum.
3. Gibt uns an wie das Wetter voraussichtlich wird.
4. Gibt uns die aktuelle Temperatur in Celsius.
5. Gibt uns die aktuelle Luftfeuchtigkeit.
6. Gibt den Pfad an wo das aktuelle Bild zum Wetter liegt.
7. Gibt uns die aktuelle Windstärke und Richtung.
8. Gibt uns den Wochentag.
9. Gibt uns die Mindesttemperatur.
10. Gibt uns die Maximaltemperatur.

Erstellen eines Proxy-Services

Da wir nun die XML-Struktur verstanden und uns die für uns wichtigen Punkte herausgesucht haben, geht es daran die API mit Silverlight zu Konsumieren. Hier tritt das erste Problem auf. Silverlight bekommt keinen Zugriff auf die Google API, da es keine crossdomain.xml und keine clientaccesspolicy.xml findet, die Silverlight die Berechtigung zum Zugriff gibt. Silverlight braucht eine von diesen beiden Dateien. In diesen Dateien gibt der Eigentümer an auf welche Services und Inhalte von wem zugegriffen werden darf und auf welche nicht. Die clientaccesspolicy.xml ist speziell für Silverlight entwickelt worden. Die crossdomain.xml wird von Flash verwendet aber da diese Datei schon ziemlich viel Verwendung im Internet hatte haben sich die Entwickler von Silverlight dafür entschlossen das Silverlight auch nach der crossdomain.xml-Datei sucht. Allerdings nur wenn es keine clientaccesspolicy.xml findet und wenn in der crossdomain.xml der Zugriff von allen Domänen gestattet wird. Um trotzdem mit Silverlight auf die Google Weather API zugreifen zu können, ist ein Proxy-Service notwendig, der sich auf der Download Domäne der Silverlight Applikation befindet und die Anfragen an die API stellt. Einen solchen Service erstellen wir an dieser Stelle.

Zur Verdeutlichung:

Den Proxy Service erstellen Sie, indem Sie zuerst eine Silverlight Applikation mit aktivem WCF-Dienst erstellen. Nun fügen Sie einen WCF Service hinzu, der später auf die Google Weather API zugreifen wird.

Diesen lassen wir nun die Google Weather API ansprechen. Hierzu verwenden wir den WebClient und den StreamReader. Folglich müssen wir den Google Weather API Link als Stream deklarieren.

using System;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.Net;
using System.IO;
 
namespace WeatherApp.Web
{
    [ServiceContract(Namespace = "")]
    [SilverlightFaultBehavior]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class GoogleWeatherApiService
    {
        [OperationContract]
        public string GetGoogleWeatherApiString(string _strCity)
        {
            WebClient client = new WebClient();
            Stream stream = client.OpenRead("http://www.google.com/ig/api?weather=" + _strCity + "&hl=De");
            using (StreamReader streamReader = new StreamReader(stream, System.Text.Encoding.Default))
            {
                return streamReader.ReadToEnd();
            }
        }
        // Add more operations here and mark them with [OperationContract]
    }
}

In dem Link der Google API befindet sich der String _strCity, da der User später seine Stadt eingeben können soll.
Nun fügen Sie der Silverlight Applikation eine neue Service Referenz hinzu, in dem Sie mit der rechten Maustaste auf Referenzen klicken und dann Service Referenz hinzufügen auswählen. Wenn Sie dies getan haben öffnet sich folgendes Fenster:

Über Ermitteln wird Visual Studio 2010 Ihren WCF-Service automatisch erkennen.

Klassendiagramm

Jetzt ist es an der Zeit sich Gedanken darüber zu machen, wie unsere Applikation funktionieren soll. Ich empfehle hierzu ein Klassendiagramm, welches Sie in Visual Studio 2010 durch Rechtsklick auf die Klasse erstellen können. Wir brauchen drei verschiedene Klassen, eine zum Auslesen der Service Referenz und zwei, denen wir die ausgelesenen Daten übermitteln lassen, damit wir später Listen dieser Klassen anfertigen können. In meinem Fall heißen diese Klassen “Data”, “Current” und “Forecast”.

Welche Methode für was zuständig ist und was es mit dem Event auf sich hat, werden wir uns später anschauen. Wichtig vorab zu wissen ist nur, dass die Variablen alle private deklariert wurden und die Eigenschaften der “Current” und “Forecast” Klassen später die Variablen verändern.

Erstellen der Klassen

Da wir nun wissen, was unsere Klassen beinhalten sollen erstellen wir diese. Ich habe mit der “Current” Klassen begonnen.

public class Current
    {
        private string _strCity;
        private DateTime _oDate = new DateTime();
        private string _strCondition;
        private int _intTemp;
        private string _strHumidity;
        private string _strWindCondition;
        private string _strImage;
    }

Nun müssen wir die Variablen Verkapseln, damit wir diese später von außerhalb verändern lassen können. Hierzu klicken sie einfach mit der rechten Maustaste auf die Variable klicken dann auf Umgestalten und wählen Einkapseln aus.

Wenn Sie dies getan haben wird sich ein Fenster öffnen in dem Sie den Namen der Variable angeben sollen:

Wenn Sie nun auf “OK” klicken wird die Verkapselung automatisch von Visual Studio 2010 generiert und sieht nun so aus:

private string _strCity;
 
        public string strCity
        {
            get { return _strCity; }
            set { _strCity = value; }
        }

Dies machen Sie für jede Variable in der Klasse “Current”.
Nun können wir mit der Klasse “Forecast” beginnen. In dieser müssen Sie ebenfalls die Variablen als privat deklarieren und diese dann Verkapseln.

public class Forecast
    {
        private string _strDay;
        private int _intLowTemp;
        private int _intHighTemp;
        public int intHighTemp;
        private string _strCondition;
        public string strCondition;
        private string _strImage;
        public string strImage;
    }

Wenn Sie mit diesen beiden Klassen fertig sind und jede Variable Verkapselt haben, können Sie mit der Data-Klasse beginnen. Diese wird auf die Service Referenz zugreifen und das vom Proxy-Service abgefragte in einen String einspeichern. Dieser String wird mittels XmlReader ausgelesen und die für uns wichtigen Daten den entsprechenden Klassen übergeben und dann eine Liste der Klasse erstellt.

Zuerst deklarieren wir die für uns wichtigen Variablen und Listen. Hier brauchen wir keinerlei Verkapselung, da auf diese Variablen von anderen Klassen nicht zugegriffen wird.

public class Data
    {
 
                private string _strCity;
                private string _strDate;
                private string _strCurrentCondition;
                private string _strCondition;
                private string _strCurrentTemp;
                private string _strHumidity;
                private string _strWindCondition;
                private string _strDay;
                private string _strLowTemp;
                private string _strHighTemp;
                private string _strImage;
                private string _strWeatherData; 
 
                public List listCurrentList = new List();
                public List listForecastList = new List();

Nun werden wir uns darum kümmern, dass das vom WCF-Service an die Referenz übergebene in einen String eingespeichert wird.

public void LoadData(string _strCity)
        {
            GoogleWeatherApiServiceClient client = new GoogleWeatherApiServiceClient();
            client.GetGoogleWeatherApiStringCompleted += new EventHandler
                (client_GetGoogleWeatherApiStringCompleted);
            client.GetGoogleWeatherApiStringAsync(_strCity);
        }
 
        void client_GetGoogleWeatherApiStringCompleted
            (object sender, GetGoogleWeatherApiStringCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                _strWeatherData = e.Result;
                GetData();
                FireXMLReaderReady();
            }
        }

Zur “GetData()”-Methode, die hier ausgeführt wird, kommen wir später. Die “FireXMLReaderReady()”-Methode werden wir jetzt implementieren. Die “FireXMLReaderReader()”-Methode entsteht durch ein Event, das wir erstellen müssen, da die Daten Asynchron geladen werden. Durch das eben genannte asynchrone Laden kann es passieren, dass die Daten noch nicht fertig geladen sind, wenn wir auf diese zugreifen wollen. Um dieses Problem zu lösen werden wir ein Event erstellen, das ausgelöst wird, wenn die Daten in den String eingetragen wurden.

public event EventHandler XMLReaderReady;
 
                public void FireXMLReaderReady()
                {
                    if (XMLReaderReady != null)
                        XMLReaderReady(this, EventArgs.Empty);
                }

Wenn wir dieses Event erstellt haben kommen wir zum Hauptteil, indem wir die für uns wichtigen Daten aus dem String auslesen und an die entsprechenden Klassen übergeben lassen.

   private void GetData()
        {
            Current OCurrent = new Current();
            Forecast OForecast = new Forecast();            
 
            using (XmlReader reader = XmlReader.Create(new StringReader(_strWeatherData)))
            {
                while (reader.Read())
                {
                    if ((reader.NodeType == XmlNodeType.Element) && (reader.LocalName != null))
                    {
                        if (reader.HasAttributes)
                        {
 
                            if (("icon" == reader.LocalName))
                            {
                                _strImage = reader.GetAttribute("data");
                            }
                            if (("city" == reader.LocalName))
                            {
                                _strCity = TranslateFerderalState( reader.GetAttribute("data"));
                            }
 
                            if (("forecast_date" == reader.LocalName))
                            {
                               _strDate = reader.GetAttribute("data");
                            }
 
                            if (("condition" == reader.LocalName))
                            {
                               _strCurrentCondition = reader.GetAttribute("data");
                               _strCondition = reader.GetAttribute("data");
                            }
 
                            if (("temp_c" == reader.LocalName))
                            {
                                _strCurrentTemp = reader.GetAttribute("data");
                            }
 
                            if (("humidity" == reader.LocalName))
                            {
                                _strHumidity = reader.GetAttribute("data");
                            }
 
                            if (("wind_condition" == reader.LocalName))
                            {
                                _strWindCondition = reader.GetAttribute("data");
                            }
 
                            if (("day_of_week" == reader.LocalName))
                            {
                                _strDay = reader.GetAttribute("data");
                            }
 
                            if (("low" == reader.LocalName))
                            {
                                _strLowTemp = reader.GetAttribute("data");
                            }
 
                            if (("high" == reader.LocalName))
                            {
                                _strHighTemp = reader.GetAttribute("data");
                            }
 
                            if(_strCity != null && _strCity!= "" && _strDate != null && _strDate != "" &&
                                _strCurrentCondition != null && _strCurrentCondition != "" &&
                                _strCurrentTemp != null && _strCurrentTemp != "" && _strHumidity != null &&
                                _strHumidity != "" && _strWindCondition != null && _strWindCondition != "" &&
                                _strImage != null && _strImage != "")
                            {
                                OCurrent.strCity = _strCity;
                                _strDate = ConvertStringToDate(_strDate);
                                OCurrent.ODate = DateTime.Parse(_strDate);
                                OCurrent.strCondition = _strCurrentCondition;
                                OCurrent.intTemp = Convert.ToInt32(_strCurrentTemp);
                                OCurrent.strHumidity = _strHumidity;
                                OCurrent.strWindCondition = _strWindCondition;
                                _strImage = ConvertToShortPath(_strImage);
                                OCurrent.strImage = _strImage;                               
 
                                listCurrentList.Add(OCurrent);
                                OCurrent = new Current();
 
                                _strHumidity = "";
                                //_strCity = "";
                                _strDate = "";
                                _strCurrentCondition = "";
                                _strCondition = "";
                                _strCurrentTemp = "";
                                _strWindCondition = "";
                            }
 
                            if(_strCondition != null && _strCondition != "" && _strLowTemp != null &&
                                _strLowTemp != "" && _strHighTemp != null && _strHighTemp != "" &&
                                _strDay != null && _strDay != "" && _strImage != null && _strImage != "")
                            {
                                OForecast.intHighTemp = Convert.ToInt32(_strHighTemp);
                                OForecast.intLowTemp = Convert.ToInt32(_strLowTemp);
                                OForecast.strCondition = _strCondition;
                                OForecast.strDay = _strDay;
                                _strImage = ConvertToShortPath(_strImage);
                                OForecast.strImage = _strImage;
 
                                listForecastList.Add(OForecast);
                                OForecast = new Forecast();
 
                                _strDay = "";
                                _strHighTemp = "";
                                _strLowTemp = "";
                                _strCondition = "";
                                _strImage = "";
                            }
                        }
                    }
                }
            }
        }

Hier sehen sie mehrere Prüfungen. Wir lassen prüfen, ob das was wir benötigen, z.B. “City”, vorhanden ist. Ist dies der Fall wird es in unsere lokale Variable eingetragen. Wenn diese Prüfungen alle durchlaufen wurden wird noch geprüft ob alle Daten vorhanden sind, welche die Klassen “Current” und “Forecast” benötigen. Trifft dies zu werden die Daten an die Verkapselten Variablen übergeben und direkt danach wird die entsprechende Klasse in ihre Liste eingetragen. Da nicht alle Daten so Formatiert sind, dass sie für uns sofort brauchbar sind, brauchen wir noch drei Methoden die uns helfen die Daten in das richtige Format umzuwandeln.
Als erstes brauchen wir die Methode “ConvertStringToDate()”, welche uns das übergebene Datum, z.B. 2011-10-24 in ein für uns brauchbares Format bringt z.B. 24.10.2011.

private static string ConvertStringToDate(string _strDate)
        {
 
            string[] arrDateSplitted = _strDate.Split('-');
            _strDate = arrDateSplitted[2] + "." + arrDateSplitted[1] + "." + arrDateSplitted[0];
            return _strDate;
        }

Desweiteren brauchen wir die Methode “ConvertToShortPath()”, die uns den von der Google API gegebenen Link für das Bild kürzt. Dies ist notwendig um später schneller auf die Bilder zugreifen zu können.

private static string ConvertToShortPath(string _strImage)
        {
            string[] arrPathSplitted = _strImage.Split('/', '.');
            _strImage = arrPathSplitted[4];
            return _strImage;
        }

Falls Sie wollen, das die Ausgabe der Städte und Bundesländer in deutsch erfolgt, brauchen Sie noch die Methode “TranslateFerderalState()”.

private static string TranslateFerderalState(string _strCity)
        {
            string[] arrCitySplitted = _strCity.Split(',');       
 
            if (arrCitySplitted[0] == "Munich")
            {
                arrCitySplitted[0] = "München";
            }
            else if(arrCitySplitted[0] == "Cologne")
            {
                arrCitySplitted[0] = "Köln";
            }
            else if(arrCitySplitted[0] == "Hanover")
            {
                arrCitySplitted[0] = "Hannover";
            }
 
            else if (arrCitySplitted[0] == "Nuremberg")
            {
                arrCitySplitted[0] = "Nürnberg";
            }
 
            if (arrCitySplitted.Length == 2)
            {
                if (arrCitySplitted[1] == " Thuringia")
                {
                    arrCitySplitted[1] = " Thüringen";
                }
 
                else if (arrCitySplitted[1] == " Saxony")
                {
                    arrCitySplitted[1] = " Sachsen";
                }
 
                else if (arrCitySplitted[1] == " Rhineland-Palatinate")
                {
                    arrCitySplitted[1] = " Rheinland Pfalz";
                }
 
                else if (arrCitySplitted[1] == " Saxony-Anhalt")
                {
                    arrCitySplitted[1] = " Sachsen Anhalt";
                }
 
                else if (arrCitySplitted[1] == " Hesse")
                {
                    arrCitySplitted[1] = " Hessen";
                }
 
                else if (arrCitySplitted[1] == " Mecklenburg-West Pommerania")
                {
                    arrCitySplitted[1] = " Mecklenburg Vorpommern";
                }
 
                else if (arrCitySplitted[1] == " North Rhine-Westphalia")
                {
                    arrCitySplitted[1] = " Nordrhein-Westfalen";
                }
 
                else if (arrCitySplitted[1] == " Lower Saxony")
                {
                    arrCitySplitted[1] = " Niedersachsen";
                }
 
                else if (arrCitySplitted[1] == " Bavaria")
                {
                    arrCitySplitted[1] = " Bayern";
                }
                else
                {
                    arrCitySplitted[1] = arrCitySplitted[1];
                }
                _strCity = arrCitySplitted[0] + "," + arrCitySplitted[1];
            }
 
            return _strCity;
        }

Erstellen der GUI

Nach der Implementierung der Logik müssen wir noch die GUI (Grafische Benutzeroberfläche) entwerfen und dafür sorgen, dass die Daten auch korrekt übergeben und angezeigt werden.

Entwerfen wir zuerst die GUI:

Meinen XAML-Code finden Sie in meiner Projektmappe.

Lassen Sie Ihrer Fantasie freien lauf und gestalten Sie die Oberfläche so wie Sie es möchten.

Als Bilder benutze ich die standard Google Weather-Bilder. Um dies ebenfalls zu tun laden sie diese einfach runter und wandeln Sie diese von “.gif” zu “.png” um, da Silverlight “.gif” nicht verwenden kann. Bei mir liegen diese Bilder dann in der Projektmappe in einem separaten Ordner Namens “GoogleWeatherImages”.

Achtung: sollten Sie sich entschließen Ihre GUI anders zu gestalten müssen Sie darauf achten, dass die Übergabe der Daten auf die GUI anders aussehen wird als bei meinem Beispiel.

Bevor wir mit der Übergabe der Daten an die GUI beginnen müssen wir erst einmal dafür sorgen, dass unser Projekt beim Start die “LoadData()”-Methode der Klasse Data ausführt. Daraufhin soll dann das Event “FireXMLReaderReady()” gefeuert werden.

        Data OData = new Data();
        List listCurrentList = new List();
        List listForecastList = new List();              
 
        public Weather()
        {
            OData.LoadData("Berlin");
            InitializeComponent();
            OData.XMLReaderReady += new EventHandler(OData_XMLReaderReady);
        }
 
        private string _strImagePath = "/WeatherApp;component/GoogleWeatherImages/";
        private string _strDate;

 void OData_XMLReaderReady(object sender, EventArgs e)
        {
            try
            {
                listCurrentList = OData.listCurrentList;
                listForecastList = OData.listForecastList;
                BuildApp();
            }
            catch (Exception)
            {
                MessageBox.Show("Bitte eine korrekte Stadt eingeben.");
            }
        }

private void BuildApp()
        {
            _strDate = listCurrentList[0].ODate.ToShortDateString();
            _strDate = FormateDateString(_strDate);
 
            _lblCityLable.Content = "Wetter in " + listCurrentList[0].strCity + ":";
            _lblConditionLabel.Content = listCurrentList[0].strCondition;
            _lblMinMaxLabel.Content = "Min" + listForecastList[0].intLowTemp + "°C" + "|" + "Max" + listForecastList[0].intHighTemp + "°C";
            _lblHumidityLabel.Content = listCurrentList[0].strHumidity;
            _lblWindConditionLabel.Content = listCurrentList[0].strWindCondition;
            _lblCurrentTempLabel.Content = "Aktuell: " + listCurrentList[0].intTemp + "°C";
            _lblTodayLable.Content = "Heute, der " + _strDate + "(" + listForecastList[0].strDay + ")";
            _imgTodayImage.Source = new BitmapImage(new Uri(_strImagePath + listCurrentList[0].strImage + ".png", UriKind.RelativeOrAbsolute));
 
            _lblDay1Label.Content = listForecastList[1].strDay;
            _lblDay1MinMaxLabel.Content = listForecastList[1].intLowTemp + "°|" + listForecastList[1].intHighTemp + "°";
            _imgDay1Image.Source = new BitmapImage(new Uri(_strImagePath + listForecastList[1].strImage + ".png", UriKind.RelativeOrAbsolute));
 
            _lblDay2Label.Content = listForecastList[2].strDay;
            _lblDay2MinMaxLabel.Content = listForecastList[2].intLowTemp + "°|" + listForecastList[2].intHighTemp + "°";
            _imgDay2Image.Source = new BitmapImage(new Uri(_strImagePath + listForecastList[2].strImage + ".png", UriKind.RelativeOrAbsolute));
 
            _lblDay3Label.Content = listForecastList[3].strDay;
            _lblDay3MinMaxLabel.Content = listForecastList[3].intLowTemp + "°|" + listForecastList[3].intHighTemp + "°";
            _imgDay3Image.Source = new BitmapImage(new Uri(_strImagePath + listForecastList[3].strImage + ".png", UriKind.RelativeOrAbsolute));
        }

Auch hier benötigen wir wieder eine Hilfsmethode, die das Datum kürzt.

private string FormateDateString(string _strDate)
        {
            string[] arrDateSplitted = _strDate.Split('.');
 
            _strDate = arrDateSplitted[0] + "." + arrDateSplitted[1];
 
            return _strDate;
        }

Wenn Sie nun Ihre Applikation Debuggen ermittelt diese nur für die Stadt das Wetter, die sie beim Start der Applikation mit der “LoadData()”-Methode übergeben haben. Um dem Benutzer die Möglichkeit zu bieten das Wetter einer eingegebenen Stadt zu sehen, müssen wir das Button Click Event implementieren.

 private void _btnCalculateWeather_Click(object sender, RoutedEventArgs e)
        {
            string _strCity = _txtCity.Text;           
 
            listCurrentList.Clear();
            listForecastList.Clear();
 
            _txtCity.Text = "";            
 
            OData.LoadData(_strCity);
        }

Nun ist die Applikation fertig und sieht wie folgt aus:

Meine Projektmappe können Sie hier herunterladen.

Dies kann zu ungewünschten Nebeneffekten führen, wenn man z.B. ein Label mit einem Klick versieht, weil die Auswahl viel größer als die Zeile ist.

Man das recht einfach lösen, in dem man nur den ersten Tag “<” in der richtigen Schriftgrösse und Formatierung belässt. Die restlichen Zeichen können in einer kleineren Schriftgrösse eingestellt werden. Dies kann bis zu Grösse “1″ minimiert werden.

Danach kann man das Feld auf die gewünschte Grösse formatieren und die Auswahl stimmt dann während der Laufzeit.

Der launchd Mechanismus ist ein ziemlich schlaues Verfahren zur Verwaltung von Systemdiensten und Hintergrundprozessen. Einer meiner folgenden Artikel wird sich speziell mit diesem Thema befassen.

Die vom launchd regelmäßig ausgeführten Wartungsmaßnahmen sind:
* periodic daily – /System/Library/LaunchDaemons/com.apple.periodic-daily.plist
* periodic weekly – /System/Library/LaunchDaemons/com.apple.periodic-weekly.plist
* periodic monthly – /System/Library/LaunchDaemons/com.apple.periodic-monthly.plist

Es gibt schon zahlreiche Artikel (u.a. diesen hier) die sich mit dem Thema befassen, was da genau im Hintergrund getan wird. Doch wenige zeigen einem, wie man die Uhrzeit des Ablaufs anpaßt.
Zum Beispiel funktioniert der Mechanismus auf unserem Mac Server ohne Probleme (der Server ist ja auch rund um die Uhr angeschaltet).

zebra:~ super$ cd /var/log
zebra:log super$ ls -ltr *.out
-rw-r--r--  1 root  wheel    1653 Oct  1 05:30 monthly.out
-rw-r--r--  1 root  wheel    6269 Oct 15 03:15 weekly.out
-rw-r--r--  1 root  wheel  455430 Oct 21 03:15 daily.out

Hingegen werden diese Systempflegemaßnahmen auf meinem MacBook eigentlich nie ausgeführt, denn zwischen 3 und 6 Uhr mogens ist der entweder im Stromsparmodus schlafen gelegt oder ganz ausgeschaltet.

Man kann die Skripte natürlich manuell aus dem Terminal Programm starten, doch zwischen 12 und 13 Uhr mittags ist bei mir eine gute Zeit wann diese auf meinem mobilen Computer automatisch ihren Dienst tun können. Also ändern wir das, und das geht bspw. so …

[super@sequoia:LaunchDaemons]? cd /System/Library/LaunchDaemons
[super@sequoia:LaunchDaemons]? sudo vi com.apple.periodic*
....

Wer den vi noch nicht bedienen kann, findet hier eine Anleitung.

Will man die Änderungen hingegen im Xcode 4 mit dem eingebauten Property List Editor durchführen, dann sind dazu mehr Anpassungen nötig.

[super@sequoia:LaunchDaemons]? cd /System/Library/LaunchDaemons
[super@sequoia:LaunchDaemons]? sudo chmod o+w . com.apple.periodic*
[super@sequoia:LaunchDaemons]? open -a /Developer/Applications/Xcode.app com.apple.periodic*
....
[super@sequoia:LaunchDaemons]? sudo chmod g-w,o-w . com.apple.periodic*
[super@sequoia:LaunchDaemons]? sudo chown root:wheel com.apple.periodic*
[super@sequoia:LaunchDaemons]? sudo xattr -d com.apple.xcode.PlistType com.apple.periodic*

Warum bloß soviel Zusatzaufwand für das bißchen mehr an Komfort?
Nun es ist so, daß Xcode zum einen die geänderten Dateien dem Benutzer und seiner primären Gruppe übereignet, und zusätzlich noch Metadaten den Dateien hinzufügt.
Wenn Metadaten zu einer Datei existieren, wird das durch ein @ kenntlich gemacht …

[super@sequoia:LaunchDaemons]? ls -le@ com.apple.periodic*
-rw-rw-r--@ 1 super staff  - 612 23 Okt 10:46 com.apple.periodic-daily.plist
	com.apple.xcode.PlistType	  0 
-rw-rw-r--@ 1 super staff  - 665 21 Okt 14:01 com.apple.periodic-monthly.plist
	com.apple.xcode.PlistType	  0 
-rw-rw-r--@ 1 super staff  - 667 21 Okt 14:01 com.apple.periodic-weekly.plist
	com.apple.xcode.PlistType	  0

Die hier ausgegeben Zeilen zeigen die Dateirechte, welche nach dem Speichern der Änderungen vorherrschten, bevor die Kommandos zum Herstellen des ursprünglichen Zustandes ausgeführt wurden.
Einer meiner folgenden Artikel wird sich noch genauer mit diesem Thema auseinandersetzen.

Die eigentlich durchzuführenden Änderungen liegen auf der Hand …

periodic-daily.plist

                <key>Hour</key>
		<integer>12</integer>
		<key>Minute</key>
		<integer>13</integer>

Jeden Tag um 12:13 Uhr geht es mit der täglichen Pflege los.

periodic-weekly.plist

		<key>Hour</key>
		<integer>12</integer>
		<key>Minute</key>
		<integer>23</integer>
		<key>Weekday</key>
		<integer>1</integer>

Jeden Montag (Sonntag = 0) kommen um 12:23 Uhr die wöchentlichen Pflegemaßnahmen hinzu. Als Standard ist hier der Samstag (6) eingetragen. Aber ich arbeite nicht jedes Wochenende, so kommt mir persönlich der Montag gelegener.

periodic-monthly.plist

		<key>Hour</key>
		<integer>12</integer>
		<key>Minute</key>
		<integer>37</integer>
		<key>Day</key>
		<integer>1</integer>

Und an jedem ersten im Monat werden um 12:37 Uhr die monatlichen Pflegevorgänge gestartet.
Natürlich werden diese Einstellung erst nach dem erneuten Laden der Konfigurationsdateien aktiviert. Ganz sicher ist das nach einem Neustart des Systems der Fall.

Dem Thema wie man mit Time Machine auf verschiedenen Medien Sicherungen durchführen kann widmet sich ein Artikel auf Macworld.

Und das Thema wie die lokalen Sicherungen verwaltet werden, wird auf der Seite von Alexander Wilde sehr ausführlich erklärt.

Technisch funktioniert dieses Verfahren so …

[root@sequoia:~]# mount
/dev/disk1 on / (hfs, local, journaled)
devfs on /dev (devfs, local, nobrowse)
map -hosts on /net (autofs, nosuid, automounted, nobrowse)
map auto_home on /home (autofs, automounted, nobrowse)
localhost:/gT1vdKfZjhVeYqEnaYXbbb on /Volumes/MobileBackups (mtmfs, nosuid, read-only, nobrowse)

Die Sicherungen sind im Verzeichnis /Volumes/MobileBackups bereitgestellt und befinden sich in der etwas kryptischen Freigabe localhost:/gT1vdKfZjhVeYqEnaYXbbb.

[root@sequoia:~]? ls -l /Volumes/
drwxrwxrwx  0 root  wheel  0 Oct 21 08:23 MobileBackups
lrwxr-xr-x  1 root  admin  1 Oct 21 08:22 sequoia_hd0 -> /
[root@sequoia:~]? ls -l /Volumes/MobileBackups/Backups.backupdb/sequoia/
drwxr-xr-x@ 3 root  wheel  102 Oct 21 08:23 2011-10-15-163456
drwxr-xr-x@ 3 root  wheel  102 Oct 21 08:23 2011-10-16-174223
drwxr-xr-x@ 3 root  wheel  102 Oct 21 08:23 2011-10-17-180254
drwxr-xr-x@ 3 root  wheel  102 Oct 21 08:23 2011-10-18-180544
lrwxrwxrwx  0 root  wheel    0 Oct 21 08:22 Latest -> 2011-10-18-180544

Auf der Festplatte liegen die lokalen Sicherungen im versteckten Ordner /.MobileBackups.

[root@sequoia:Volumes]? ls -la /
drwxr-xr-x  23 root  wheel      1156 Oct 16 15:44 .
drwxr-xr-x  23 root  wheel      1156 Oct 16 15:44 ..
-rw-rw-r--   1 root  admin     15364 Oct 13 16:09 .DS_Store
d--x--x--x   7 root  wheel       238 Oct 16 15:44 .DocumentRevisions-V100
drwxr-xr-x+  3 root  wheel       102 Oct 14 07:26 .MobileBackups
drwx------   4 root  wheel       170 Oct 13 13:34 .Spotlight-V100
d-wx-wx-wt   2 root  staff        68 Oct 13 13:09 .Trashes
.....

Nach dem Ausschalten der lokalen Sicherungen, sind diese Verzeichnisse verschwunden und der verbrauchte Platz wieder freigegeben.

Unsere 1. App-Entwicklung wurde mit xCode 4 durchgeführt. Zuerst wurde ein Layout in Photoshop CS5 erstellt, wie die App im fertigen Zustand aussehen soll.

Das Grundgerüst hat der Entwickler dann in xCode nachgebaut. Jeder der App Beteiligten hat auf seinem Laptop mittels VCS Subversion V1.6 lokal einen Ordner angelegt, in diesem das Projekt samt Dateien und Bilder gespeichert wurde.

Nach und nach wurden aus dem Photoshop Layout einzelne Grafiken abgespeichert, diese im Images Ordner abgelegt und im xCode Projekt eingepflegt.

Was ist dabei zu beachten?
Die Grafiken müssen nach Abspeichern im lokalen Projektordner auch noch im xCode Projekt dem Projekt hinzugefügt werden, indem man im xCode mit Rechtsklick auf den Ordner “Images” klickt und dann “Add files to …”.

Danach müssen die neu hinzugefügten Daten noch commited werden, damit der Projektpartner die Änderungen auch auf seinem Arbeitsplatz sehen und damit arbeiten kann.

Farblehre für unsere xCode Anwendung
Die Farbangaben werden in xCode nicht in reinen RGB Werten angezeigt.
Hier ein Beispiel aus unserem Clock View: { 255.0/255.0f, 217.0/255.0f, 83.0/255.0f, 1.0f }  Das ist die Farbe Gelb vom Ziffernblatt.
Der 1. Wert von 255.0/255.0f ist beispielsweise der 1. RGB Wert = Rot
Der 2. Wert 217.0/255.0f ist Grün und der 3. Wert von 83.0/255.0f ist Blau.
Der 4. Wert steht für den Alpha Wert.

Wie kommen die Werte zustande?
Erklären ist das Ganze so, dass der Wert vor dem Slash der RGB Farbwert ist und man die 255.0f nach dem Slash erstmal nicht zu beachten braucht. Das f steht für den float. Ist der Alpha-Wert 0.0, so ist die Farbe vollkommen transparent, ist er 1.0, so ist die Farbe opak.

Wie sind die Grafiken abzuspeichern?
iPhone 3GS/iPad: reichen die 72dpi und die normale Größe des iPhones. Das heißt 320 x 480Pixel.
Für die 4. Generation des iPhones und alle Retina Displays ist die Auflösung von 72dpi auch noch ausreichend. Allerdings wird hier empfohlen die Grafiken mit der doppelten Pixelanzahl zu belegen. Das heißt wenn eine Grafik, zum Beispiel ein Logo für das iPhone 3GS/iPad eine Größe von 120 x 80 Pixel hat, ist die Größe für Retina Displays 240 x 160 Pixel.

Wenn der Entwickler nun etwas programmiert hat committed er die Dateien somit die anderen Personen, die an dem Projekt mitarbeiten, sich ein “Update” ziehen können.

Wozu ist das gut?
Somit sind beide Parteien immer auf dem aktuellen Stand. Entwickelt nun der Entwickler und der Gestalter an der selben Datei und beide wollen die Datei gleichzeitig committen wird gefragt, ob die Datei “gemerged” werden soll. Das heißt, die Änderungen der einzelnen Personen werden erst aufgezeigt und dann werden beide Änderungen in die eine Datei zusammengeführt und diese eine Datei wird dann abgespeichert. Wer das nun nicht verstanden hat kann sich hier zum Thema “Merge” noch einmal schlau lesen.

Wer kann die Apps verwalten?
Es kann pro Firma 1 Agent bei Apple angelegt sein. Das bedeutet, dass 1 Person die neu erstellte App im App-Store anmelden kann. Wenn man eine Entwickler ID hat (kostenlos) und von dem TeamAgent dann in das Entwicklerteam eingebunden/eingeladen wird, dann kann der Entwickler mit der kostenlosen ID auch Applikationen auf einem Testgerät ausführen, welches vom selben TeamAgent als Entwicklungsgerate für sein Team registriert wurde.

Fazit
Das Zusammenspiel zwischen Entwickler und Gestaltung war sehr spannend, da immer kleine Neuerungen vom Entwickler kamen, wie in unserem Fall zum Beispiel das Erscheinen eines Wasserdampfes. Und für mich, die Gestalterin war es super anzusehen wie meine Grafiken langsam in der App Gestalt annahmen.

Zunächst einmal handelt es sich dabei um nichts Neues. Auf Mac OS wurden diese Dateiattribute mit Mac OS 10.4 (Tiger) eingeführt, welche offiziell am 29. April 2005 erschien.
Die meisten anderen Betriebssysteme hatten ACLs schon bedeutend länger mit an Bord.
Der Funktionsumfang dieser erweiterten Dateizugriffsrechte liegt im wesentlichen im zugrunde gelegten Dateisystem verankert. Und bezüglich Mac OS X haben sich vor einigen Jahren auch schon andere damit befaßt.

Die Befehle, welche man zum Anschauen und zur Bearbeitung von ACLs benutzt lauten:
* ls -le
* chmod +a

Und was soll das jetzt?

Zum einen wird man manchmal unfreiwillig damit konfrontiert, davon handelt mein vorangehender Artikel.
Zum anderen gibt es denkbar viele Anwendungsfälle, welche sich mit ACLs sehr geschickt und einfach lösen lassen. Greifen wir uns also einen heraus …

1. Individuelle Drop Box

Ein jeder Mac OS X Benutzer stellt für andere Anwender eine Ablage für Dateien bereit, deren Inhalt sie aber nicht sehen können bzw. dürfen.
Nun wäre es manchmal hilfreich, einer einzelnen Person das Recht einräumen zu können in ein solches Verzeichnis hineinzuschauen, was denn schon drin liegt. Also eine individuelle Drop Box anlegen.

Man schaut sich die aktuellen Rechte an …

$ ls -le
drwx-wx-wx+ 2 martin  staff   102  8 Okt 09:30 Drop Box
 0: user:martin allow list,add_file,search,delete,add_subdirectory,delete_child,
    readattr,writeattr,readextattr,writeextattr,readsecurity,writesecurity,
    chown,file_inherit,directory_inherit
 1: user:_spotlight inherited allow list,search,file_inherit,directory_inherit
 
-rw-r--r--+ 1 martin  staff  1711  8 Okt 09:11 mac_rastetter-gpg.asc
 0: user:_spotlight inherited allow read,execute

Das der Kennzeichnung der Zugriffsrechte nachgestellte + Zeichen, gibt einem den Hinweis es sind ACLs für diese Datei gesetzt. Diese werden je Benutzer bzw. Gruppe von dem Befehl ls -le aufgelistet.
ACL 0 : Der Besitzer (martin) des Verzeichnisses bekommt explizit alle Rechte
ACL 1 : Der Spotlight Dienst (_spotlight) darf alles darinnen befindliche lesen und durchsuchen
Bei einer darinnen befindlichen Datei (mein öffentlicher PGP Schlüssel) hat jeder Leserechte und unabhängig davon, wie ich die gewöhnlichen Dateirechte einschränkte, blieb dem Spotlight Dienst die Möglichkeit den Inhalt zu lesen bzw. diese auszuführen (wozu auch immer).

Nun legen wir ein Verzeichnis mit individueller Berechtigung an …

$ cp -Rp Drop\ Box Ina\'s\ Box
$ chmod o-wx Ina\'s\ Box
$ chmod g-wx Ina\'s\ Box
$ chmod +a "ina allow list" Ina\'s\ Box
$ chmod +a "ina allow add_file" Ina\'s\ Box
$ chmod +a "ina allow search" Ina\'s\ Box
$ chmod +a "ina deny delete_child" Ina\'s\ Box

Wir kopieren also das Verzeichnis Drop Box mit Inhalt (in diesem Fall hoffentlich leer) und allen Berechtigungen und nennen es Ina’s Box.
Dann nehmen wir allen anderen Benutzern und jenen der eigenen Gruppe (staff s.o.) alle Rechte.
Wir erlauben nur der Benutzerin ina sich den Inhalt des Verzeichnisses anzusehen, Dateien hinzuzufügen,
darin zu suchen und verbieten das Löschen.

Das ganze sieht dann wie folgt aus …

$ ls -le
drwx-wx-wx+ 2 martin  staff   204 10 Okt 08:46 Drop Box
 0: user:martin allow list,add_file,search,delete,add_subdirectory,delete_child,
    readattr,writeattr,readextattr,writeextattr,readsecurity,writesecurity,
    chown,file_inherit,directory_inherit
 1: user:_spotlight inherited allow list,search,file_inherit,directory_inherit
drwx------+ 2 martin  staff   306 10 Okt 08:47 Ina's Box
 0: user:ina deny delete_child
 1: user:ina allow list,add_file,search
 2: user:martin allow list,add_file,search,delete,add_subdirectory,delete_child,
    readattr,writeattr,readextattr,writeextattr,readsecurity,writesecurity,
    chown,file_inherit,directory_inherit
 3: user:_spotlight inherited allow list,search,file_inherit,directory_inherit
-rw-r--r--+ 1 martin  staff  1711  8 Okt 09:11 mac_rastetter-gpg.asc
 0: user:_spotlight inherited allow read,execute

So, jetzt wollen wir schauen ob und wie es funktioniert.
Alle Benutzer sehen mein öffentliches Verzeichnis im Finder wie folgt:

Wohingegen die Benutzerin ina mein öffentliches Verzeichnis im Finder wie folgt dargestellt bekommt:

Und siehe da, diese Benutzerin kann mir dort nicht nur Dateien hinterlegen, sondern diese und deren Inhalt kontrollieren.

Die tatsächlichen Rechte sehen dann wie folgt aus.

$ ls -le Ina\'s\ Box/
-rw-r--r--+ 1 ina  staff  1188252 15 Sep  2009 ObjC.pdf
 0: user:martin inherited allow read,write,execute,delete,append,
    readattr,writeattr,readextattr,writeextattr,readsecurity,writesecurity,
    chown
 1: user:_spotlight inherited allow read,execute
-rw-r--r--+ 1 ina  staff      124 10 Okt 08:40 maxosx_extensions.txt
 0: user:martin inherited allow read,write,execute,delete,append,
    readattr,writeattr,readextattr,writeextattr,readsecurity,writesecurity,
    chown
 1: user:_spotlight inherited allow read,execute

Man kann erkennen, daß bei den Dateien die Rechte vom Verzeichnis vererbt (inherited) wurden, sowie keine Verzeichnisattribute gesetzt sind.
Die allgemeinen Zugriffsrechte bleiben erhalten.
Will die Besitzerin die Dateien löschen, wird das abgelehnt, bzw. mit der Frage nach dem Kennwort des Administrators quittiert (der darf sowieso alles).
Nachträgliche Änderungen an den Dateien sind mit Mac Texteditoren (TextEditor, XCode) nicht mehr möglich, wohingegen auf der Unix Kommandoebene keine Einschränkungen bestehen.

$cd ~martin/Public
$ echo "Hallo Welt ... wie geht's?" >> Ina\'s\ Box/maxosx_extensions.txt 
$ tail -1 Ina\'s\ Box/maxosx_extensions.txt 
Hallo Welt ...wie geht's?

Man erwartet eigentlich auch genau dieses Verhalten, dennoch behaupten o.g. Editoren die Datei sei gesperrt?!
Vielleicht will ja ein interessierter Leser dieser Sache näher auf den Grund gehen …

Nutzer der Apple Mac OS X Betriebssystemfamilie greifen dabei gerne auf das Softwarepaket GPGTools zurück. Eine deutsche Installationsanleitung erlaubt selbst technischen Laien eine problemlose Installation der Software.
Unabhängig davon, ob man einige der Funktionen nun direkt aus irgendwelchen Anwendungen nutzen will, kann ein gewöhnlicher Anwender unter Mac OS 10.7 (Lion) weder ent- noch verschlüsseln. Und das sollte generell schon möglich sein!

Schaut man in der Konsole Anwendung, fallen einem Meldungen der Art

08.10.11 09:43:30,335 org.gpgtools.macgpg2.gpg-agent: gpg-agent[5844]: 
    error binding socket to `/Users/myuser/.gnupg/S.gpg-agent': Invalid argument

ins Auge. Und man stellt fest, daß der persönliche GPG Agent nicht läuft.

$ ps uxw | grep gpg

bzw.

$ launchctl list | grep gpg
	-	(2) org.gpgtools.macgpg2.gpg-agent

Die Zahl in Klammern ist die Fehlernummer, welcher beim Startversuch des Agenten auftritt.

Nun gut, sucht man im Internet … dann findet man zu diesem Thema einige Konversationen direkt mit den Entwicklern der Software.
1. Diskussion vom Januar 2011
2. Diskussion vom Juni 2011
Und siehe da, man erkennt sofort es werden bei Mac OS 10.7 (Lion) viel häufiger als in den vorhergehenden Versionen dieser Betriebssystemfamilie sogenannte ACLs (= Access Control Lists, zu deutsch sind damit erweiterte Zugriffsberechtigungen auf Dateiebene gemeint) verwendet werden.

Beheben wir zunächst das Problem, und schauen uns dieses Phänomen danach noch etwas genauer an (in einem meiner nachfolgenden Beiträge).

So nimmt man alle ACLs vom benutzereigenen GnuPG Verzeichnis weg …

$ cd ~
$ chmod -R -a# 0 .gnupg

… dann startet man den Agenten erneut und schaut, ob er diesmal läuft …

$ launchctl start org.gpgtools.macgpg2.gpg-agent
$ launchctl list | grep gpg
213	-	org.gpgtools.macgpg2.gpg-agent

Die Zahl vorne ist die Prozeßkennung des Agenten.

Bei Interesse kann man sich Details zum Agenten anzeigen lassen …

$ launchctl list org.gpgtools.macgpg2.gpg-agent

… und das sollte etwa so aussehen.

{
	"Label" = "org.gpgtools.macgpg2.gpg-agent";
	"LimitLoadToSessionType" = "Background";
	"OnDemand" = true;
	"LastExitStatus" = 0;
	"PID" = 213;
	"TimeOut" = 30;
	"ProgramArguments" = (
		"/usr/local/MacGPG2/bin/gpg-agent";
		"--launchd";
		"--write-env-file";
	);
};

Und jetzt klappt auch die Ent- und Verschlüsselung wieder, bspw. …

$ gpg -d -o decoded.file encoded.file 
Sie benötigen eine Passphrase, um den geheimen Schlüssel zu entsperren.
Benutzer: "Martin Rastetter <martin@baden.de>"
1024-Bit ELG Schlüssel, ID EE827F34, erzeugt 2005-01-09 (Hauptschlüssel-ID D94AFAD0)
gpg: verschlüsselt mit 1024-Bit ELG Schlüssel, ID F3D63379, erzeugt 2008-11-03
      "Fritz Fuchs <fritzle@schwaben.de>"
gpg: verschlüsselt mit 1024-Bit ELG Schlüssel, ID EE827F34, erzeugt 2005-01-09
      "Martin Rastetter <martin@baden.de>"
gpg: Signatur vom Mi 27 Mai 12:01:06 2009 CEST mittels DSA-Schlüssel ID 63525EE3
gpg: Korrekte Signatur von "Fritz Fuchs <fritzle@schwaben.de>"
Haupt-Fingerabdruck  = CA62 6DD9 CE88 4D3D 0621  1343 6806 7B58 6352 5EE3

Bestens, ab jetzt können wir wieder mit GnuPG arbeiten wie wir es bisher gewohnt waren.

Was?

- Wie erstelle ich eine eigene PDF Export-Vorgabe in InDesign.

Warum?

- Probleme ggf. schon vor dem Export aus dem Weg gehen.
- Zeit sparen beim richtigen Exportieren.

Wer in InDesign Dokumente für die Druckerei exportiert, wird in den meißten Fällen auf das bewährte “Exportieren als > PDF X3 2002″ zurückgegriffen. Manchmal macht es Sinn ein eigenes Ausgabeprofil anzulegen, dies möchte ich euch hier erklären.

Achtung: Besonders für Upgrades von der Adobe Creative Suite 5.0 auf 5.5 ist es ratsam noch einmal speziell auf den Punkt Ausgabe zu achten, welche das Farbprofil für das Dokument verwalten kann. In einigen bekannten Fällen wird dieses beim Upgrade nämlich standardmäßig auf U.S. Webcoated (SWOP) gestellt! In anderen Fällen wird es auf das US Webcoated SWOP gewechselt sobald man die Ausgabe-Version von z.B. Acrobat 4 (PDF 1.3) auf eine höhere Version einstellt, wird diese im Hintergrund auch die “Ausgabe” (also die Farbkonvertierung) ändern.

Was ist denn PDF/X ?

Bevor man weiß wie man eine PDF/X Vorgabe anlegen kann, lohnt es sich vielleicht erstmal ein wenig zu verstehen was das denn ist!

Das PDF/X ist ein Dateiformat das den Austausch von Druckdaten vereinfachen soll. Diese PDF/X Standards sind sogar nach ISO genormt. Das allgemeine PDF/X wird im ISO 15929 beschrieben, auf die einzelnen Versionen geht dann die ISO 15930-x genauer ein. Kurz gesagt, nach diesem PDF/X Standard wird entschieden welche Informationen in die PDF kommen und für die Druckerei wichtig sind um eine gutes Ergebnis zu gewährleisten.

Die unterschiedlichen Zahlen (PDF/X1; X3, X4…) beschreiben einzelne Elemente welche die PDF enthalten soll/muss.
Um genau zu erklären welches Format was unterstützt würde hier den Rahmen sprengen. Eine direkte Anlaufstelle hierfür findet ihr auf der ISO-Seite.

Kurzum für PDF/X4: zusätzlich zu CMYK, Graustufen, RGB und Schmuckfarben, werden auch Transparenzen, Ebenen, OpenType-Fonts, JPEG2000 und 16-bit Bilddaten zugelassen.

Die Verarbeitung der Transparenzen werden im PDF/X4 (im Ablauf der Verarbeitung) weiter nach hinten gelegt, dadurch werden einige alte Probleme mit Transparenzen behoben bzw. treten garnicht erst auf. Mit diesen Transparenzen wird aber erst ab Acrobat (und Acrobat Reader) Version 7.0 richtig umgegangen. Das bedeutet dass man beim Export auch mind. die PDF Version 1.6 verwenden sollte.

Wichtig: Es ist unerlässlich das man genau weiss welches Format die Druckerei später auch verarbeiten kann! Wenn die Druckerei nicht über eine sogenannte PDF Print Engine verfügt, kann es mit X4 zu Problemen kommen. Normalerweise können alle modernen Druckereien die X4 verarbeiten, einige empfehlen dies sogar. Es gibt aber dennoch viele günstige Online-Druckservices welche nur das X3 Format akzeptieren!

Eigenes Exportprofil erstellen

1. Wenn ihr InDesign geöffnet habt, geht ihr auf
Datei > Adobe PDF-Vorgaben > Definieren…

2. Im neuen Fenster könnt ihr die Vorgaben schnell überblicken.
Ich wähle für meine neue Vorgabe PDFX4 2008 und klicke auf Neu… ,
Nun wird eine neue Vorlage angelegt mit den Vorgaben basierend auf der PDFX4 2008.

3. Im neuen Fenster könnt ihr der neuen Vorgabe erst einmal einen für euch passenden Namen vergeben. Ich nenne meine Vorlage PDFX4 2008 – Eigene Vorlage.

Für diese Version müsste als “Standard” schon die PDF/X-4:2010 gewählt sein und die Kompatibilität Acrobat 7 (PDF 1.6).

Auf dem Reiter Allgemein mache ich keine weiteren Änderungen und belasse alles ohne Haken.

4. Komprimierung

Die Art der Bildberechnung sollte überall auf Bikubische Neuberechnung stehen. Diese Werte bitte nur abändern wenn ihr genau wisst was die verschiedenen Optionen bedeuten um unerwünschte Effekte zu vermeiden. Im allgemeinen kann man mit der Bikubischen Neuberechnung nichts falsch machen.

Ebenfalls die Qie Komprimierung und die Bildqualität auf jeweils Automatisch (JPEG) bzw. Maximum für die Druckerei ist genau richtig. Lediglich bei Bildern mit mehr als 450 Pixel pro Zoll stelle ich hier den Wert auf 600 (wie mir von einer Druckerei empfohlen wurde).

5. Marken und Anschnitt

Bei den Druckmarken aktivieren viele Leute gerne alle Häkchen, weil das Dokument danach so toll technisch aussieht. In den meißten Fällen benötigen die meißten Druckereien nur die Schnittmarken. Die Seiteninformationen sind häufig auch sehr hilfreich.
Der Versatz kann aus Sicherheitsgründen auf 3 mm erweitert werden. Dies regelt z.B. die Distanz der Schnittmarken zu dem Dokumenteninhalt.

Den Haken bei Anschnittseinstellungen des Dokuments verwenden lasse ich in dieser Vorlage deaktiviert, dafür stelle ich aber einen Standard-Anschnitt von 3 mm für alle Seiten. Wenn eine Druckerei einen genauen Anschnittsbereich haben möchte (einige Online-Services bitten darum) dann lege ich diese in den Dokumenteneigenschaften an und wähle beim Export dann Anschnittseinstellungen des Dokuments verwenden.

6. Ausgabe

Wer von der InDesign Version 5.0 auf 5.5 upgedatet hat, bei dem kann es passieren dass bei einigen PDF/X-Versionen die Farbkonvertierung auf U.S. Webcoated (SWOP) automatisch voreingestellt wird. Hier würde ich keine Farbkonvertierung empfehlen, weiter unten bei “Name des Ausgabemethodenprofils” habe ich Dokument-CMYK gewählt. Für diese beiden Werte ist die eigene Arbeitsweise ausschlaggebend.

Ich empfehle die Bilder schon in dem richtigen Farbprofil anzulegen. Wenn dies aus irgend einem Grund nicht gemacht werden kann (Zeitmangel oder sonstiger abstrakter Grund) kann man hier die Farbkonvertiertung für Bilder ohne Farbprofil steuern und auf ein gewünschtes Profil beim Export ändern lassen. Dies kann dann ggf. mit unvorhergesehenen Farbvarianten enden. Nicht alle Farbänderungen haben auch Auswirkung in der Ansicht der gespeicherten PDF. Wenn die Druckerei die Druckplatten belichtet kann es hier zu Abweichungen kommen.

7. Erweitert

Bei diesen Punkt habe ich keine Änderungen durchgeführt.

8. Übersicht

Hier solltet ihr darauf achten ob links ein Ausrufezeichen in einem gelben Dreieck zu sehen ist (eine Warnung). Ist dies der Fall, solltet ihr der Sache nachgehen. Genauere Informationen hierzu findet ihr dann in dem Reiter “Übersicht” im unteren Bereich unter “Warnungen”.

Mit einem Klick auf OK speichert ihr eure neue Vorgabe.

Fazit:

Mit diesen Vorgaben solltet ihr in den meißten Fällen schon sehr gut liegen. Natürlich müsst ihr, je nach Druckdokument und Druckerei die Werte (wie z.B. Farbprofile für gestrichenes oder nicht gestrichenes Papier) richtig setzen, oder eben das richtige Ausgabeformat wählen (wie oben schon beschrieben, manche Druckereien nehmen nur X3 Dokumente).
Neben PDF Vorgaben für die Druckerei lohnt es sich auch Vorgaben für PDFs zu erstellen die nur einen schnellen Text-Review benötigen, in diesen Fällen kann man die Qualität der Bilder stark einschränken. Genauso wie PDFs die nur für den Bildschirm gedacht sind, hier kann man auch viele Megabytes sparen. Für solche Fälle gibt es zwar die vordefinierten “Press Quality” und “Small File Size”-Vorgaben, nun wisst ihr ja wie man an dieser Stelle Vorgaben nach eigenem Wunsch erstellt.

Interaktive eLearning

HTML Dokumentation

PDF Dokumentation

Wichtig: Die eLearning Einheit können Sie nur mit dem Firefox oder dem Internet Explorer ansehen. Falls Sie uns mit einem anderen Browser besuchen, bitten wir Sie hierfür Browser zu wechseln.