Überarbeitungsverlauf

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. Allerdings überschreiben dann ggf. die Optionen, die man in der Wrapper-Klasse setzt, die Optionen von `\documentclass`. Siehe dazu das Beispiel `scrartcl-wrapper` Version 0.1b unten. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Entferne alle `\makeatletter` und `\makeatother` außerhalb von Umgebungs- und Makro-Definitionen. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1a demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Oder ohne das Wissen bezüglich der Verarbeitung von `twoside` und `DIV=calc`: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1b demo wrapper class] \LoadClassWithOptions{scrartcl} \KOMAoptions{twoside,DIV=calc} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Allerdings hat diese zweite Fassung den Nachteil, dass es nichts nützt, wenn man Option `twoside=false` bei `\documentclass` angibt, da das `\KOMAoptions` der Wrapper-Klasse nach dem Laden der Klasse `scrartcl` und damit nach dem Laden von `typearea` ausgeführt wird. Ich empfehle daher, die erste Version. Und wie macht man das, wenn die Auswahl der Basisklasse per Option erfolgen soll? Auch kein Problem: \begin{filecontents}{koma-wrapper.cls} \ProvidesClass{koma-wrapper}[2013/08/26 v0.1 demo wrapper class] \newcommand*{\BaseClass}{scrartcl}% \DeclareOption{book}{\renewcommand*{\BaseClass}{scrbook}} \DeclareOption{report}{\renewcommand*{\BaseClass}{scrreprt}} \DeclareOption{article}{\renewcommand*{\BaseClass}{scrartcl}} \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{\BaseClass}} \ProcessOptions\relax \LoadClass{\BaseClass} \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. \end{filecontents} \documentclass[book,titlepage,oneside]{koma-wrapper} \usepackage{blindtext} \begin{document} \title{Titel} \author{Ich} \maketitle \blinddocument \end{document} Übrigens: Sehr allgemeine Namen wie "uebungsblaetter" für eine Klasse oder ein Paket zu verwenden ist meist nur sinnvoll, wenn die Klasse bzw. das Paket auch wirklich sehr allgemein angelegt ist. Wobei es dann sinnvoller wäre, einen englischen Namen zu wählen und das ganze auf [CTAN][1] bereit zu stellen. Für ganz spezielle Klassen und Pakete sollte man möglichst auch sehr spezielle Namen wie "uebblatt-inf-uni-dingens" verwenden. Wenn nämlich jeder Fachbereich seine spezielle Klasse für Übungsblätter "uebungsblaetter" nennt, dann haben wir bald einige hundert gleich benannte aber unterschiedliche Klassen und niemand blickt mehr durch. [1]: http://www.ctan.org

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option ~~verarbeitet.~~ verarbeitet. Allerdings überschreiben dann ggf. die Optionen, die man in der Wrapper-Klasse setzt, die Optionen von `\documentclass`. Siehe dazu das Beispiel `scrartcl-wrapper` Version 0.1b unten. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Entferne alle `\makeatletter` und `\makeatother` außerhalb von Umgebungs- und Makro-Definitionen. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1a demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Oder ohne das Wissen bezüglich der Verarbeitung von `twoside` und `DIV=calc`: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1b demo wrapper class] \LoadClassWithOptions{scrartcl} \KOMAoptions{twoside,DIV=calc} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Allerdings hat diese zweite Fassung den Nachteil, dass es nichts nützt, wenn man Option `twoside=false` bei `\documentclass` angibt, da das `\KOMAoptions` der Wrapper-Klasse nach dem Laden der Klasse `scrartcl` und damit nach dem Laden von `typearea` ausgeführt wird. Ich empfehle daher, die erste Version. Und wie macht man das, wenn die Auswahl der Basisklasse per Option erfolgen soll? Auch kein Problem: \begin{filecontents}{koma-wrapper.cls} \ProvidesClass{koma-wrapper}[2013/08/26 ~~v0.1a~~ v0.1 demo wrapper class] \newcommand*{\BaseClass}{scrartcl}% \DeclareOption{book}{\renewcommand*{\BaseClass}{scrbook}} \DeclareOption{report}{\renewcommand*{\BaseClass}{scrreprt}} \DeclareOption{article}{\renewcommand*{\BaseClass}{scrartcl}} \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{\BaseClass}} \ProcessOptions\relax \LoadClass{\BaseClass} \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. \end{filecontents} \documentclass[book,titlepage,oneside]{koma-wrapper} \usepackage{blindtext} \begin{document} \title{Titel} \author{Ich} \maketitle \blinddocument \end{document}

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Entferne alle `\makeatletter` und `\makeatother` außerhalb von Umgebungs- und Makro-Definitionen. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1a demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Oder ohne das Wissen bezüglich der Verarbeitung von `twoside` und `DIV=calc`: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1b demo wrapper class] \LoadClassWithOptions{scrartcl} \KOMAoptions{twoside,DIV=calc} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Allerdings hat diese zweite Fassung den Nachteil, dass es nichts nützt, wenn man Option `twoside=false` bei `\documentclass` angibt, da das `\KOMAoptions` der Wrapper-Klasse nach dem Laden der Klasse `scrartcl` und damit nach dem Laden von `typearea` ausgeführt wird. Ich empfehle daher, die erste Version. Und wie macht man das, wenn die Auswahl der Basisklasse per Option erfolgen soll? Auch kein Problem: \begin{filecontents}{koma-wrapper.cls} \ProvidesClass{koma-wrapper}[2013/08/26 v0.1a demo wrapper class] \newcommand*{\BaseClass}{scrartcl}% \DeclareOption{book}{\renewcommand*{\BaseClass}{scrbook}} \DeclareOption{report}{\renewcommand*{\BaseClass}{scrreprt}} \DeclareOption{article}{\renewcommand*{\BaseClass}{scrartcl}} \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{\BaseClass}} \ProcessOptions\relax \LoadClass{\BaseClass} \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. \end{filecontents} \documentclass[book,titlepage,oneside]{koma-wrapper} \usepackage{blindtext} \begin{document} \title{Titel} \author{Ich} \maketitle \blinddocument \end{document}

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Entferne alle `\makeatletter` und `\makeatother` außerhalb von Umgebungs- und Makro-Definitionen. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1a demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Oder ohne das Wissen bezüglich der Verarbeitung von `twoside` und `DIV=calc`: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1b demo wrapper class] \LoadClassWithOptions{scrartcl} \KOMAoptions{twoside,DIV=calc} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Allerdings hat diese zweite Fassung den Nachteil, dass es nichts nützt, wenn man Option `twoside=false` bei `\documentclass` angibt, da das `\KOMAoptions` der Wrapper-Klasse nach dem Laden der Klasse `scrartcl` und damit nach dem Laden von `typearea` ausgeführt wird. Ich empfehle daher, die erste ~~Version.~~Version. Und wie macht man das, wenn die Auswahl der Basisklasse per Option erfolgen soll? Auch kein Problem: \begin{filecontents}{koma-wrapper.cls} \ProvidesClass{koma-wrapper}[2013/08/26 v0.1a demo wrapper class] \newcommand*{\BaseClass}{scrartcl}% \DeclareOption{book}{\renewcommand*{\BaseClass}{scrbook}} \DeclareOption{report}{\renewcommand*{\BaseClass}{scrreprt}} \DeclareOption{article}{\renewcommand*{\BaseClass}{scrartcl}} \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{\BaseClass}} \ProcessOptions\relax \LoadClass{\BaseClass} \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. \end{filecontents} \documentclass[book,titlepage,oneside]{koma-wrapper} \usepackage{blindtext} \begin{document} \title{Titel} \author{Ich} \maketitle \blinddocument \end{document}

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Entferne alle `\makeatletter` und `\makeatother` außerhalb von Umgebungs- und Makro-Definitionen. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1a demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Oder ohne das Wissen bezüglich der Verarbeitung von `twoside` und `DIV=calc`: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1b demo wrapper class] \LoadClassWithOptions{scrartcl} \KOMAoptions{twoside,DIV=calc} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Allerdings hat diese zweite Fassung den Nachteil, dass es nichts nützt, wenn man Option `twoside=false` bei `\documentclass` angibt, da das `\KOMAoptions` der Wrapper-Klasse nach dem Laden der Klasse `scrartcl` und damit nach dem Laden von `typearea` ausgeführt wird. Ich empfehle daher, die erste Version.

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 ~~v0.1~~ v0.1a demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Oder ohne das Wissen bezüglich der Verarbeitung von `twoside` und `DIV=calc`: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1b demo wrapper class] \LoadClassWithOptions{scrartcl} \KOMAoptions{twoside,DIV=calc} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden. Allerdings hat diese zweite Fassung den Nachteil, dass es nichts nützt, wenn man Option `twoside=false` bei `\documentclass` angibt, da das `\KOMAoptions` der Wrapper-Klasse nach dem Laden der Klasse `scrartcl` und damit nach dem Laden von `typearea` ausgeführt wird. Ich empfehle daher, die erste Version.

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1 demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden.

Eigentlich geht das ganz einfach: - Kopiere die komplette Präambel in eine Datei mit Endung `.cls`. - Setze als erste Zeile: \ProvidesClass{uebungsblatt}[2013/08/26 v0.1 Uebungsblaetterklasse von Clemens] - Ändere `\documentclass` in `\LoadClass`. - Ändere `\usepackage` in `\RequirePackage`. - Kopiere alle Optionen, die keine Optionen der Klasse sind oder die auch von Paketen verarbeitet werden sollen in das optionale Argument der entsprechenden `\RequirePackage`-Anweisungen. Für KOMA-Script-Optionen bietet es sich stattdessen an, diese nach dem Laden aller KOMA-Script-Pakete mit `\KOMAoptions` zu setzen, weil man dann gar nicht erst wissen muss, welches Paket welche Option verarbeitet. - Entferne Pakete wie `inputenc`, die eher vom Dokument/Editor abhängen als von der Dokumentart. Diese sollten weiterhin besser im Dokument geladen werden. - Füge ein `\ProcessOptions\relax` hinzu. Das sollte es für eine einfache Wrapper-Klasse gewesen sein. Etwas mehr Aufwand wird es, wenn die Wrapper-Klasse Optionen verarbeiten soll. Der einfachste Fall dabei wäre, dass die zugrunde liegende Klasse mit den Optionen geladen werden soll, mit der Deine Wrapper-Klasse bei `\documentclass` geladen wird. Dazu muss man `\LoadClassWithOptions` statt `\LoadClass` verwenden. Diese Anweisung hat selbst allerdings kein optionales Argument. Hatte man zuvor `\LoadClass` mit optionalem Argument verwendet, so kann man die dort angegebenen Optionen nun stattdessen per `\PassOptionsToClass` (vor `\LoadClassWithOptions`) oder per `\ExecuteOptions` (vor `\ProcessOptions`) ausführen. Via `\PassOptionsToClass` kann man auch Optionen explizit weiterreichen, beispielsweise als: \DeclareOption{twoside}{\PassOptionsToClass{twoside}{foo}} oder \DeclareOption*{\expandafter\PassOptionsToClass\expandafter{\CurrentOption}{foo}} wobei hier `foo` die zugrunde liegende Basisklasse ~~ist.~~ist. Eine ganz einfache Wrapper-Klasse für `scrartcl` könnte also beispielsweise so aussehen: \ProvidesClass{scrartcl-wrapper}[2013/08/26 v0.1 demo wrapper class] \PassOptionsToPackage{twoside,DIV=calc}{typearea}% Diese beiden Optionen sollen Voreinstellung sein % und werden bei KOMA-Script nicht von der Klasse, sondern von typearea verarbeitet. \LoadClassWithOptions{scrartcl} \ProcessOptions\relax \RequirePackage{xcolor}% Die Wrapper-Klasse soll immer auch das Paket xcolor laden.