From c0a72ca298b91cdf3fddf8ffc398fe58379a1d50 Mon Sep 17 00:00:00 2001 From: Artur Wyszynski Date: Sat, 12 Sep 2009 03:08:40 +0000 Subject: [PATCH] merged r33072 from gallium3d branch (OpenGL preferences) git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33074 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- build/jam/HaikuImage | 2 +- src/preferences/Jamfile | 1 + src/preferences/opengl/CapabilitiesView.cpp | 223 ++++++++++++++++++++ src/preferences/opengl/CapabilitiesView.h | 25 +++ src/preferences/opengl/ExtensionsList.cpp | 47 +++++ src/preferences/opengl/ExtensionsList.h | 33 +++ src/preferences/opengl/ExtensionsView.cpp | 78 +++++++ src/preferences/opengl/ExtensionsView.h | 26 +++ src/preferences/opengl/InfoView.cpp | 119 +++++++++++ src/preferences/opengl/InfoView.h | 25 +++ src/preferences/opengl/Jamfile | 17 ++ src/preferences/opengl/LogoView.cpp | 71 +++++++ src/preferences/opengl/LogoView.h | 28 +++ src/preferences/opengl/OpenGL.rdef | 45 ++++ src/preferences/opengl/OpenGLApp.cpp | 39 ++++ src/preferences/opengl/OpenGLApp.h | 28 +++ src/preferences/opengl/OpenGLView.cpp | 90 ++++++++ src/preferences/opengl/OpenGLView.h | 29 +++ src/preferences/opengl/OpenGLWindow.cpp | 49 +++++ src/preferences/opengl/OpenGLWindow.h | 29 +++ src/preferences/opengl/OpenGL_logo.png | Bin 0 -> 4466 bytes 21 files changed, 1003 insertions(+), 1 deletion(-) create mode 100644 src/preferences/opengl/CapabilitiesView.cpp create mode 100644 src/preferences/opengl/CapabilitiesView.h create mode 100644 src/preferences/opengl/ExtensionsList.cpp create mode 100644 src/preferences/opengl/ExtensionsList.h create mode 100644 src/preferences/opengl/ExtensionsView.cpp create mode 100644 src/preferences/opengl/ExtensionsView.h create mode 100644 src/preferences/opengl/InfoView.cpp create mode 100644 src/preferences/opengl/InfoView.h create mode 100644 src/preferences/opengl/Jamfile create mode 100644 src/preferences/opengl/LogoView.cpp create mode 100644 src/preferences/opengl/LogoView.h create mode 100644 src/preferences/opengl/OpenGL.rdef create mode 100644 src/preferences/opengl/OpenGLApp.cpp create mode 100644 src/preferences/opengl/OpenGLApp.h create mode 100644 src/preferences/opengl/OpenGLView.cpp create mode 100644 src/preferences/opengl/OpenGLView.h create mode 100644 src/preferences/opengl/OpenGLWindow.cpp create mode 100644 src/preferences/opengl/OpenGLWindow.h create mode 100644 src/preferences/opengl/OpenGL_logo.png diff --git a/build/jam/HaikuImage b/build/jam/HaikuImage index db9110b55b..ba9ae13703 100644 --- a/build/jam/HaikuImage +++ b/build/jam/HaikuImage @@ -71,7 +71,7 @@ SYSTEM_APPS = AboutSystem ActivityMonitor CharacterMap CodyCam DeskCalc DiskProb ShowImage SoundRecorder StyledEdit Terminal TextSearch TV Workspaces ; SYSTEM_PREFERENCES = Appearance Backgrounds CPUFrequency DataTranslations E-mail - FileTypes Fonts Keyboard Keymap Media Mouse Network Printers + FileTypes Fonts Keyboard Keymap Media Mouse Network OpenGL Printers Screen ScreenSaver Sounds Time Touchpad Tracker VirtualMemory ; SYSTEM_DEMOS = BSnow Chart Clock Cortex FontDemo diff --git a/src/preferences/Jamfile b/src/preferences/Jamfile index d0502a8d0b..a864a66297 100644 --- a/src/preferences/Jamfile +++ b/src/preferences/Jamfile @@ -17,6 +17,7 @@ SubInclude HAIKU_TOP src preferences mail ; SubInclude HAIKU_TOP src preferences media ; SubInclude HAIKU_TOP src preferences mouse ; SubInclude HAIKU_TOP src preferences network ; +SubInclude HAIKU_TOP src preferences opengl ; SubInclude HAIKU_TOP src preferences print ; SubInclude HAIKU_TOP src preferences screen ; SubInclude HAIKU_TOP src preferences screensaver ; diff --git a/src/preferences/opengl/CapabilitiesView.cpp b/src/preferences/opengl/CapabilitiesView.cpp new file mode 100644 index 0000000000..13bad41478 --- /dev/null +++ b/src/preferences/opengl/CapabilitiesView.cpp @@ -0,0 +1,223 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "CapabilitiesView.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +void +AddStringView(BView* view, const char* viewName, const char* name, + const char* value, bool spacer) +{ + if (!view) + return; + + BRect dummyRect(0, 0, 0, 0); + const float kSpacer = 5; + + BString tempViewName(viewName); + BStringView *nameView = new BStringView(dummyRect, tempViewName.String(), + name, B_FOLLOW_NONE); + tempViewName.Append("Value"); + BStringView *valueView = new BStringView(dummyRect, tempViewName.String(), + value, B_FOLLOW_NONE); + + if (spacer) { + view->AddChild(BGroupLayoutBuilder(B_VERTICAL) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(nameView) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(valueView) + ) + .Add(BSpaceLayoutItem::CreateVerticalStrut(kSpacer)) + ); + } else { + view->AddChild(BGroupLayoutBuilder(B_VERTICAL) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(nameView) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(valueView) + ) + ); + } +} + + +CapabilitiesView::CapabilitiesView() + : BView("Capabilities", 0, NULL) +{ + SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); + SetLayout(new BGroupLayout(B_VERTICAL)); + + BRect dummyRect(0, 0, 0, 0); + + const float kInset = 10; + + int lights = 0; + int clippingPlanes = 0; + int modelStack = 0; + int projectionStack = 0; + int textureStack = 0; + int maxTex3d = 0; + int maxTex2d = 0; + int nameStack = 0; + int listStack = 0; + int maxPoly = 0; + int attribStack = 0; + int buffers = 0; + int convolutionWidth = 0; + int convolutionHeight = 0; + int maxIndex = 0; + int maxVertex = 0; + int textureUnits = 0; + + glGetIntegerv(GL_MAX_LIGHTS, &lights); + glGetIntegerv(GL_MAX_CLIP_PLANES, &clippingPlanes); + glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &modelStack); + glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &projectionStack); + glGetIntegerv(GL_MAX_TEXTURE_STACK_DEPTH, &textureStack); + glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &maxTex3d); + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTex2d); + glGetIntegerv(GL_MAX_NAME_STACK_DEPTH, &nameStack); + glGetIntegerv(GL_MAX_LIST_NESTING, &listStack); + glGetIntegerv(GL_MAX_EVAL_ORDER, &maxPoly); + glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH, &attribStack); + glGetIntegerv(GL_AUX_BUFFERS, &buffers); + glGetIntegerv(GL_MAX_CONVOLUTION_WIDTH, &convolutionWidth); + glGetIntegerv(GL_MAX_CONVOLUTION_HEIGHT, &convolutionHeight); + glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &maxIndex); + glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &maxVertex); + glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &textureUnits); + + BString tempString; + BView *rootView = new BView("root view", 0, NULL); + rootView->SetLayout(new BGroupLayout(B_VERTICAL)); + + tempString << (int32) buffers; + AddStringView(rootView, "Buffers", "Auxiliary buffer(s):", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) modelStack; + AddStringView(rootView, "ModelStack", "Model stack size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) projectionStack; + AddStringView(rootView, "ProjectionStack", "Projection stack size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) textureStack; + AddStringView(rootView, "TextureStack", "Texture stack size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) nameStack; + AddStringView(rootView, "NameStack", "Name stack size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) listStack; + AddStringView(rootView, "ListStack", "List stack size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) attribStack; + AddStringView(rootView, "AttribStack", "Attributes stack size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) maxTex3d; + AddStringView(rootView, "MaxTex3D", "Maximum 3D texture size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) maxTex2d; + AddStringView(rootView, "MaxTex2D", "Maximum 2D texture size:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) textureUnits; + AddStringView(rootView, "MaxTexUnits", "Maximum texture units:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) lights; + AddStringView(rootView, "MaxLights", "Maximum lights:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) clippingPlanes; + AddStringView(rootView, "MaxClippingPlanes", "Maximum clipping planes:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) maxPoly; + AddStringView(rootView, "MaxPoly", "Maximum evaluators equation order:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) convolutionWidth << "x" << convolutionHeight; + AddStringView(rootView, "MaxConvultion", "Maximum convolution:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) maxIndex; + AddStringView(rootView, "MaxIndex", "Maximum recommended index elements:", + tempString.String(), true); + + tempString.SetTo(""); + tempString << (int32) maxVertex; + AddStringView(rootView, "MaxVertex", "Maximum recommended vertex elements:", + tempString.String(), true); + + AddChild(BGroupLayoutBuilder(B_VERTICAL) + .Add(rootView) + .SetInsets(kInset, kInset, kInset, kInset) + ); +} + + +CapabilitiesView::~CapabilitiesView() +{ + +} + + +void +CapabilitiesView::MessageReceived(BMessage* message) +{ + switch (message->what) { + default: + BView::MessageReceived(message); + } +} + + +void +CapabilitiesView::AttachedToWindow() +{ + +} + + +void +CapabilitiesView::DetachedFromWindow() +{ + +} diff --git a/src/preferences/opengl/CapabilitiesView.h b/src/preferences/opengl/CapabilitiesView.h new file mode 100644 index 0000000000..e6e4703ecc --- /dev/null +++ b/src/preferences/opengl/CapabilitiesView.h @@ -0,0 +1,25 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef CAPABILITIES_VIEW_H +#define CAPABILITIES_VIEW_H + + +#include + +class CapabilitiesView : public BView { +public: + CapabilitiesView(); + virtual ~CapabilitiesView(); + + virtual void MessageReceived(BMessage* message); + virtual void AttachedToWindow(); + virtual void DetachedFromWindow(); +}; + +#endif /* CAPABILITIES_VIEW_H */ diff --git a/src/preferences/opengl/ExtensionsList.cpp b/src/preferences/opengl/ExtensionsList.cpp new file mode 100644 index 0000000000..d7a6b428dc --- /dev/null +++ b/src/preferences/opengl/ExtensionsList.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "ExtensionsList.h" + +#include +#include + + +ExtensionRow::ExtensionRow(const char* extensionName) + : BRow(), + fExtensionName(extensionName) +{ + SetField(new BStringField(extensionName), 0); +} + + +ExtensionRow::~ExtensionRow() +{ + +} + + +ExtensionsList::ExtensionsList() + : BColumnListView("ExtensionsList", B_FOLLOW_ALL) +{ + BStringColumn* column = new BStringColumn("Available", 280, 280, 280, + B_TRUNCATE_MIDDLE); + AddColumn(column, 0); + SetSortingEnabled(true); + SetSortColumn(column, true, true); +} + + +ExtensionsList::~ExtensionsList() +{ + BRow *row; + while ((row = RowAt((int32)0, NULL)) != NULL) { + RemoveRow(row); + delete row; + } +} diff --git a/src/preferences/opengl/ExtensionsList.h b/src/preferences/opengl/ExtensionsList.h new file mode 100644 index 0000000000..814c04f773 --- /dev/null +++ b/src/preferences/opengl/ExtensionsList.h @@ -0,0 +1,33 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef EXTENSIONS_LIST_H +#define EXTENSIONS_LIST_H + + +#include +#include + + +class ExtensionRow : public BRow { +public: + ExtensionRow(const char* extensionName); + virtual ~ExtensionRow(); + +private: + BString fExtensionName; +}; + + +class ExtensionsList : public BColumnListView { +public: + ExtensionsList(); + virtual ~ExtensionsList(); +}; + +#endif /* EXTENSIONS_LIST_H */ diff --git a/src/preferences/opengl/ExtensionsView.cpp b/src/preferences/opengl/ExtensionsView.cpp new file mode 100644 index 0000000000..4e4c29fdf8 --- /dev/null +++ b/src/preferences/opengl/ExtensionsView.cpp @@ -0,0 +1,78 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "ExtensionsView.h" + +#include +#include +#include +#include +#include +#include +#include "ExtensionsList.h" + + +ExtensionsView::ExtensionsView() + : BView("Extensions", 0, NULL) +{ + SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); + SetLayout(new BGroupLayout(B_VERTICAL)); + + const float kInset = 10; + + ExtensionsList *extList = new ExtensionsList(); + + char *list = (char*)glGetString(GL_EXTENSIONS); + if (list) { + while (*list) { + char extName[255]; + int n = strcspn(list, " "); + strncpy(extName, list, n); + extName[n] = 0; + extList->AddRow(new ExtensionRow(extName)); + if (!list[n]) + break; + list += (n + 1); // next ! + } + } + + AddChild(BGroupLayoutBuilder(B_VERTICAL) + .Add(extList) + .SetInsets(kInset, kInset, kInset, kInset) + ); +} + + +ExtensionsView::~ExtensionsView() +{ + +} + + +void +ExtensionsView::MessageReceived(BMessage* message) +{ + switch (message->what) { + default: + BView::MessageReceived(message); + } +} + + +void +ExtensionsView::AttachedToWindow() +{ + +} + + +void +ExtensionsView::DetachedFromWindow() +{ + +} diff --git a/src/preferences/opengl/ExtensionsView.h b/src/preferences/opengl/ExtensionsView.h new file mode 100644 index 0000000000..50ca1da3e9 --- /dev/null +++ b/src/preferences/opengl/ExtensionsView.h @@ -0,0 +1,26 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef EXTENSIONS_VIEW_H +#define EXTENSIONS_VIEW_H + + +#include + +class ExtensionsView : public BView { +public: + ExtensionsView(); + virtual ~ExtensionsView(); + + virtual void MessageReceived(BMessage* message); + virtual void AttachedToWindow(); + virtual void DetachedFromWindow(); +}; + + +#endif /* EXTENSIONS_VIEW_H */ diff --git a/src/preferences/opengl/InfoView.cpp b/src/preferences/opengl/InfoView.cpp new file mode 100644 index 0000000000..eb99777bdc --- /dev/null +++ b/src/preferences/opengl/InfoView.cpp @@ -0,0 +1,119 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "InfoView.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +InfoView::InfoView() + : BView("Information", 0, NULL) +{ + SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); + SetLayout(new BGroupLayout(B_VERTICAL)); + + BRect dummyRect(0, 0, 0, 0); + + BStringView *version = new BStringView(dummyRect, "Version", + "OpenGL Version:", B_FOLLOW_NONE); + BStringView *versionValue = new BStringView(dummyRect, "VersionVal", + (const char*)glGetString(GL_VERSION), B_FOLLOW_NONE); + BStringView *vendor = new BStringView(dummyRect, "Vendor", + "Vendor Name:", B_FOLLOW_NONE); + BStringView *vendorValue = new BStringView(dummyRect, "VendorVal", + (const char*)glGetString(GL_VENDOR), B_FOLLOW_NONE); + BStringView *renderer = new BStringView(dummyRect, "Renderer", + "Renderer Name:", B_FOLLOW_NONE); + BStringView *rendererValue = new BStringView(dummyRect, "RendererVal", + (const char*)glGetString(GL_RENDERER), B_FOLLOW_NONE); + BStringView *gluVersion = new BStringView(dummyRect, "GLUVersion", + "GLU Version:", B_FOLLOW_NONE); + BStringView *gluVersionValue = new BStringView(dummyRect, "GLUVersionVal", + (const char*)gluGetString(GLU_VERSION), B_FOLLOW_NONE); + BStringView *glutVersion = new BStringView(dummyRect, "GLUTVersion", + "GLUT API Version:", B_FOLLOW_NONE); + BString glutApiVer; + glutApiVer << (int32)GLUT_API_VERSION; + BStringView *glutVersionValue = new BStringView(dummyRect, "GLUTVersionVal", + glutApiVer.String(), B_FOLLOW_NONE); + + const float kInset = 10; + const float kSpacer = 5; + + AddChild(BGroupLayoutBuilder(B_VERTICAL) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(version) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(versionValue) + ) + .Add(BSpaceLayoutItem::CreateVerticalStrut(kSpacer)) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(vendor) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(vendorValue) + ) + .Add(BSpaceLayoutItem::CreateVerticalStrut(kSpacer)) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(renderer) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(rendererValue) + ) + .Add(BSpaceLayoutItem::CreateVerticalStrut(kSpacer)) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(gluVersion) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(gluVersionValue) + ) + .Add(BSpaceLayoutItem::CreateVerticalStrut(kSpacer)) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(glutVersion) + .Add(BSpaceLayoutItem::CreateGlue()) + .Add(glutVersionValue) + ) + .Add(BSpaceLayoutItem::CreateGlue()) + .SetInsets(kInset, kInset, kInset, kInset) + ); +} + + +InfoView::~InfoView() +{ + +} + + +void +InfoView::MessageReceived(BMessage* message) +{ + switch (message->what) { + default: + BView::MessageReceived(message); + } +} + + +void +InfoView::AttachedToWindow() +{ + +} + + +void +InfoView::DetachedFromWindow() +{ + +} diff --git a/src/preferences/opengl/InfoView.h b/src/preferences/opengl/InfoView.h new file mode 100644 index 0000000000..9d0b351d9b --- /dev/null +++ b/src/preferences/opengl/InfoView.h @@ -0,0 +1,25 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef INFO_VIEW_H +#define INFO_VIEW_H + + +#include + +class InfoView : public BView { +public: + InfoView(); + virtual ~InfoView(); + + virtual void MessageReceived(BMessage* message); + virtual void AttachedToWindow(); + virtual void DetachedFromWindow(); +}; + +#endif /* INFO_VIEW_H */ diff --git a/src/preferences/opengl/Jamfile b/src/preferences/opengl/Jamfile new file mode 100644 index 0000000000..c7c1bf7cbe --- /dev/null +++ b/src/preferences/opengl/Jamfile @@ -0,0 +1,17 @@ +SubDir HAIKU_TOP src preferences opengl ; + +UsePrivateHeaders interface ; + +Preference OpenGL : + OpenGLApp.cpp + OpenGLWindow.cpp + OpenGLView.cpp + CapabilitiesView.cpp + ExtensionsList.cpp + ExtensionsView.cpp + InfoView.cpp + LogoView.cpp + : be GL translation libcolumnlistview.a $(TARGET_LIBSUPC++) + : OpenGL.rdef + ; + diff --git a/src/preferences/opengl/LogoView.cpp b/src/preferences/opengl/LogoView.cpp new file mode 100644 index 0000000000..45b49fb4aa --- /dev/null +++ b/src/preferences/opengl/LogoView.cpp @@ -0,0 +1,71 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Authors: + * Stephan Aßmus + * Artur Wyszynski + */ + +#include "LogoView.h" + +#include +#include +#include +#include +#include + + +LogoView::LogoView(const BRect& frame) + : BView(frame, "LogoView", B_FOLLOW_ALL, B_WILL_DRAW + | B_FULL_UPDATE_ON_RESIZE), + fLogo(NULL) +{ + SetViewColor(255, 255, 255); + fLogo = BTranslationUtils::GetBitmap(B_PNG_FORMAT, "OpenGL_logo.png"); + if (fLogo) { + SetExplicitMinSize( + BSize(fLogo->Bounds().Width(), fLogo->Bounds().Height() + 6)); + } +} + + +LogoView::~LogoView() +{ + delete fLogo; +} + + +void +LogoView::Draw(BRect update) +{ + if (!fLogo) + return; + + BRect bounds(Bounds()); + BPoint placement; + placement.x = (bounds.left + bounds.right - fLogo->Bounds().Width()) / 2; + placement.y = (bounds.top + bounds.bottom - fLogo->Bounds().Height()) / 2; + + DrawBitmap(fLogo, placement); + rgb_color borderColor = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), + B_DARKEN_3_TINT); + SetHighColor(borderColor); + StrokeLine(bounds.LeftBottom(), bounds.RightBottom()); +} + + +void +LogoView::GetPreferredSize(float* _width, float* _height) +{ + float width = 0.0; + float height = 0.0; + if (fLogo) { + width = fLogo->Bounds().Width(); + height = fLogo->Bounds().Height(); + } + if (_width) + *_width = width; + if (_height) + *_height = height; +} diff --git a/src/preferences/opengl/LogoView.h b/src/preferences/opengl/LogoView.h new file mode 100644 index 0000000000..ca022a5924 --- /dev/null +++ b/src/preferences/opengl/LogoView.h @@ -0,0 +1,28 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Authors: + * Stephan Aßmus + * Artur Wyszynski + */ + +#ifndef LOGO_VIEW_H +#define LOGO_VIEW_H + + +#include + +class LogoView : public BView { +public: + LogoView(const BRect& frame); + virtual ~LogoView(); + + virtual void Draw(BRect update); + virtual void GetPreferredSize(float* _width, float* _height); + +private: + BBitmap* fLogo; +}; + +#endif /* LOGO_VIEW_H */ diff --git a/src/preferences/opengl/OpenGL.rdef b/src/preferences/opengl/OpenGL.rdef new file mode 100644 index 0000000000..fa64618c20 --- /dev/null +++ b/src/preferences/opengl/OpenGL.rdef @@ -0,0 +1,45 @@ + +resource(1, "BEOS:APP_SIG") #'MIMS' "application/x-vnd.Haiku-OpenGL"; + +resource app_flags B_SINGLE_LAUNCH; + +resource app_version { + major = 1, + middle = 0, + minor = 0, + + variety = B_APPV_DEVELOPMENT, + internal = 0, + + short_info = "OpenGL", + long_info = "OpenGL ©2009 Haiku" +}; + +resource(1, "OpenGL_logo.png") #'PNG ' import "OpenGL_logo.png"; + +resource vector_icon { + $"6E6369660B0500020016023A3D24339506B715A93DDB134A79084A1A1100D7FF" + $"B80594020016023A3D24339506B715A93DDB134A79084A1A1100D2FF8505C402" + $"0016023A692E36692FBA2ECD3E2ECC4B89A4496318005CFF83020016023C8000" + $"0000000000003C00004AC00049000000F4FFDB03A9FF00020106033C00000000" + $"000000003C00004680004680000B9EEDFF2567CEFFFF0473B3020106033C0000" + $"0000000000003C000046800046800000B9FF97BE05D65EFF04994304016E0F0A" + $"044C60516060505C4E02043334BD6D34B7B434263926BBDC26BE0E333EB7B43E" + $"BD6D3E403940BE0E40BBDC0A0651365A395A504C5E425842400A084C444C5EC3" + $"AFCB27C3AFC72B4450C15AC9CB425842400A04C1EFC6634450C15AC9CBC1DECA" + $"180A04C317C6E8C1EFC663C1DECA18C316CACE0A04C3AFCB27C3AFC72BC317C6" + $"E8C316CACE0A0451365A394C4442400A044C445A395A504C5E0A04484648484A" + $"C3234AC2570404BE404A3246324A323E4236423C4232373202042E22BB3722B5" + $"F022222E22B5F022BB372E3AB5F03ABB373A3A2E3ABB373AB5F00608BFDBB506" + $"B560B506B560B443B638222E22B75722BAB3B717BD1FB52DBC80B717BD1F2836" + $"28322A34263024302E2828282A2826060CA2EBAF2E28B98632263428302E302C" + $"303036323436BBB3BC32BBB3BC32BCB6BB513A2E3ABA053AB668B9EDB3FDBBE9" + $"B493B9EDB3FD2E2430260614BFDDAFABE82E22B90C22B72A22B506B560B5E6B4" + $"68B506B56028282826282A242E30283226302A3436B717BD1FB717BD1FB78EBD" + $"452E3AB80E3AB9C53ABBB3BC32BADCBCEBBBB3BC3234363632302E3030302C34" + $"283226B953282E30262E24B9EDB3FDB9EDB3FDB980B3DD0D0A0A020001000A0A" + $"010A124000000000000000003FB6DB42000043249201178400040A00030A020B" + $"1001178400040A010103000A020104000A030105000A040106000A060107000A" + $"050108000A0301091001178100040A070109000A08010E000A09020C0D00" +}; + diff --git a/src/preferences/opengl/OpenGLApp.cpp b/src/preferences/opengl/OpenGLApp.cpp new file mode 100644 index 0000000000..6c1b54de11 --- /dev/null +++ b/src/preferences/opengl/OpenGLApp.cpp @@ -0,0 +1,39 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "OpenGLApp.h" +#include "OpenGLWindow.h" + + +OpenGLApp::OpenGLApp() + : BApplication("application/x-vnd.Haiku-OpenGL") +{ +} + + +OpenGLApp::~OpenGLApp() +{ +} + + +void +OpenGLApp::ReadyToRun() +{ + fWindow = new OpenGLWindow(); + fWindow->Show(); + +} + + +int main(int argc, const char** argv) +{ + OpenGLApp app; + app.Run(); + return 0; +} + diff --git a/src/preferences/opengl/OpenGLApp.h b/src/preferences/opengl/OpenGLApp.h new file mode 100644 index 0000000000..73e2fab714 --- /dev/null +++ b/src/preferences/opengl/OpenGLApp.h @@ -0,0 +1,28 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef OPENGL_APP_H +#define OPENGL_APP_H + + +#include +#include "OpenGLWindow.h" + + +class OpenGLApp : public BApplication { +public: + OpenGLApp(); + virtual ~OpenGLApp(); + + virtual void ReadyToRun(); + +private: + OpenGLWindow* fWindow; +}; + +#endif /* OPENGL_APP_H_ */ diff --git a/src/preferences/opengl/OpenGLView.cpp b/src/preferences/opengl/OpenGLView.cpp new file mode 100644 index 0000000000..88526d50dc --- /dev/null +++ b/src/preferences/opengl/OpenGLView.cpp @@ -0,0 +1,90 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "OpenGLView.h" + +#include +#include +#include +#include +#include +#include +#include "CapabilitiesView.h" +#include "ExtensionsView.h" +#include "InfoView.h" +#include "LogoView.h" + + +OpenGLView::OpenGLView() + : BView("OpenGLView", 0, NULL) +{ + SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); + SetLayout(new BGroupLayout(B_VERTICAL)); + + const float kInset = 10; + BRect dummy(0, 0, 2, 2); + + fGLView = new BGLView(dummy, "gl info", B_FOLLOW_NONE, 0, + BGL_RGB | BGL_DOUBLE); + fGLView->Hide(); + AddChild(fGLView); + + fGLView->LockGL(); + + LogoView *logoView = new LogoView(dummy); + + BTabView *tabView = new BTabView("tab view", B_WIDTH_FROM_LABEL); + + InfoView *infoView = new InfoView(); + tabView->AddTab(infoView); + + CapabilitiesView *capabilitiesView = new CapabilitiesView(); + tabView->AddTab(capabilitiesView); + + ExtensionsView *extensionsView = new ExtensionsView(); + tabView->AddTab(extensionsView); + + fGLView->UnlockGL(); + + AddChild(BGroupLayoutBuilder(B_VERTICAL) + .Add(logoView) + .Add(BGroupLayoutBuilder(B_HORIZONTAL) + .Add(tabView) + .SetInsets(kInset, kInset, kInset, kInset) + ) + ); +} + + +OpenGLView::~OpenGLView() +{ +} + + +void +OpenGLView::MessageReceived(BMessage* message) +{ + switch (message->what) { + default: + BView::MessageReceived(message); + } +} + + +void +OpenGLView::AttachedToWindow() +{ + +} + + +void +OpenGLView::DetachedFromWindow() +{ + +} diff --git a/src/preferences/opengl/OpenGLView.h b/src/preferences/opengl/OpenGLView.h new file mode 100644 index 0000000000..ebd39b52f2 --- /dev/null +++ b/src/preferences/opengl/OpenGLView.h @@ -0,0 +1,29 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef OPENGL_VIEW_H +#define OPENGL_VIEW_H + + +#include +#include + +class OpenGLView : public BView { +public: + OpenGLView(); + virtual ~OpenGLView(); + + virtual void MessageReceived(BMessage* message); + virtual void AttachedToWindow(); + virtual void DetachedFromWindow(); + +private: + BGLView* fGLView; +}; + +#endif /* OPENGL_VIEW_H */ diff --git a/src/preferences/opengl/OpenGLWindow.cpp b/src/preferences/opengl/OpenGLWindow.cpp new file mode 100644 index 0000000000..53cacdb07a --- /dev/null +++ b/src/preferences/opengl/OpenGLWindow.cpp @@ -0,0 +1,49 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#include "OpenGLWindow.h" + +#include +#include "OpenGLView.h" + + +OpenGLWindow::OpenGLWindow() + : BWindow(BRect(50, 50, 450, 400), "OpenGL", B_TITLED_WINDOW, + B_NOT_RESIZABLE | B_ASYNCHRONOUS_CONTROLS | B_NOT_ZOOMABLE + | B_AUTO_UPDATE_SIZE_LIMITS) +{ + SetLayout(new BGroupLayout(B_VERTICAL)); + fView = new OpenGLView(); + GetLayout()->AddView(fView); + CenterOnScreen(); +} + + +OpenGLWindow::~OpenGLWindow() +{ + +} + + +bool +OpenGLWindow::QuitRequested() +{ + be_app->PostMessage(B_QUIT_REQUESTED); + return true; +} + + +void +OpenGLWindow::MessageReceived(BMessage* message) +{ + switch (message->what) { + default: + BWindow::MessageReceived(message); + } +} + diff --git a/src/preferences/opengl/OpenGLWindow.h b/src/preferences/opengl/OpenGLWindow.h new file mode 100644 index 0000000000..501f085256 --- /dev/null +++ b/src/preferences/opengl/OpenGLWindow.h @@ -0,0 +1,29 @@ +/* + * Copyright 2009 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Author: + * Artur Wyszynski + */ + +#ifndef OPENGL_WINDOW_H +#define OPENGL_WINDOW_H + + +#include +#include "OpenGLView.h" + + +class OpenGLWindow : public BWindow { +public: + OpenGLWindow(); + virtual ~OpenGLWindow(); + + virtual bool QuitRequested(); + virtual void MessageReceived(BMessage* message); + +private: + OpenGLView* fView; +}; + +#endif /* OPENGL_WINDOW_H */ diff --git a/src/preferences/opengl/OpenGL_logo.png b/src/preferences/opengl/OpenGL_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..3f596cca7ede93b5e925e76b5e74c1a53fac071c GIT binary patch literal 4466 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 Ef^9aAY5)KL literal 0 HcmV?d00001