Ticket #4634: icons.diff

File icons.diff, 10.5 KB (added by VinDuv, 15 years ago)

  • src/add-ons/screen_savers/Jamfile

     
    33SubInclude HAIKU_TOP src add-ons screen_savers debugnow ;
    44SubInclude HAIKU_TOP src add-ons screen_savers flurry ;
    55SubInclude HAIKU_TOP src add-ons screen_savers haiku ;
     6SubInclude HAIKU_TOP src add-ons screen_savers icons ;
    67SubInclude HAIKU_TOP src add-ons screen_savers ifs ;
    78SubInclude HAIKU_TOP src add-ons screen_savers message ;
     9SubInclude HAIKU_TOP src add-ons screen_savers simpleclock ;
    810SubInclude HAIKU_TOP src add-ons screen_savers slideshowsaver ;
    911SubInclude HAIKU_TOP src add-ons screen_savers spider ;
    10 SubInclude HAIKU_TOP src add-ons screen_savers simpleclock ;

  • src/add-ons/screen_savers/icons/IconDisplay.cpp

     
     1/*
     2    Copyright 2009 Vincent Duvert, vincent.duvert@free.fr
     3    All rights reserved. Distributed under the terms of the MIT License.
     4*/
     5
     6#include "IconDisplay.h"
     7
     8#include <stdio.h>
     9#include <stdlib.h>
     10
     11#include <Bitmap.h>
     12#include <IconUtils.h>
     13
     14
     15#define RAND_BETWEEN(a, b) ((rand() % ((b) - (a) + 1) + (a)))
     16#define SHOW_TICKS_MIN 20
     17#define SHOW_TICKS_MAX 50
     18#define STAY_TICKS_MIN 50
     19#define STAY_TICKS_MAX 100
     20#define HIDE_TICKS_MIN 20
     21#define HIDE_TICKS_MAX 50
     22
     23
     24IconDisplay::IconDisplay()
     25    :
     26    fIsRunning(false),
     27    fBitmap(NULL)
     28{
     29}
     30
     31
     32IconDisplay::~IconDisplay()
     33{
     34    delete fBitmap;
     35}
     36
     37
     38void
     39IconDisplay::Run(VectorIcon* icon, BRect frame)
     40{
     41    delete fBitmap;
     42
     43    fBitmap = new BBitmap(BRect(0, 0, frame.Width(), frame.Height()), 0,
     44        B_RGBA32);
     45    BIconUtils::GetVectorIcon(icon->data, icon->size, fBitmap);
     46
     47    fState = 0;
     48    fTicks = 0;
     49    fDelay = RAND_BETWEEN(SHOW_TICKS_MIN, SHOW_TICKS_MAX);
     50    fFrame = frame;
     51
     52    fIsRunning = true;
     53}
     54
     55
     56void
     57IconDisplay::ClearOn(BView* view)
     58{
     59    if (!fIsRunning || fState == 2)
     60        return;
     61
     62    view->FillRect(fFrame);
     63}
     64
     65
     66void
     67IconDisplay::DrawOn(BView* view, uint32 delta)
     68{
     69    if (!fIsRunning)
     70        return;
     71
     72    fTicks += delta;
     73
     74    rgb_color backColor = view->HighColor();
     75
     76    switch (fState) {
     77        case 0: // Progressive showing
     78            if (fTicks < fDelay)
     79                backColor.alpha = (fTicks * 255) / fDelay;
     80            else
     81                fState++;
     82        break;
     83
     84        case 1: // Completed showing
     85            backColor.alpha = 255;
     86            fTicks = 0;
     87            fDelay = RAND_BETWEEN(STAY_TICKS_MIN, STAY_TICKS_MAX);
     88            fState++;
     89        break;
     90
     91        case 2: // Waiting
     92            if (fTicks < fDelay)
     93                return;
     94            fTicks = 0;
     95            backColor.alpha = 255;
     96            fDelay = RAND_BETWEEN(HIDE_TICKS_MIN, HIDE_TICKS_MAX);
     97            fState++;
     98            return;
     99        break;
     100
     101        case 3: // Progressive hiding
     102            if (fTicks < fDelay) {
     103                backColor.alpha = 255 - (fTicks * 255) / fDelay;
     104            } else {
     105                backColor.alpha = 0;
     106                fState++;
     107            }
     108        break;
     109
     110        default: // Finished
     111            fIsRunning = false;
     112            return;
     113        break;
     114    };
     115
     116    view->SetHighColor(backColor);
     117    view->DrawBitmap(fBitmap, BPoint(fFrame.left, fFrame.top));
     118    backColor.alpha = 255;
     119    view->SetHighColor(backColor);
     120}

  • src/add-ons/screen_savers/icons/IconsSaver.h

     
     1/*
     2    Copyright 2009 Vincent Duvert, vincent.duvert@free.fr
     3    All rights reserved. Distributed under the terms of the MIT License.
     4*/
     5
     6#ifndef ICONS_SAVER_H
     7#define ICONS_SAVER_H
     8
     9#include <List.h>
     10#include <ScreenSaver.h>
     11
     12
     13class IconDisplay;
     14
     15
     16class IconsSaver: public BScreenSaver {
     17public:
     18                                IconsSaver(BMessage* archive, image_id);
     19    virtual                     ~IconsSaver();
     20
     21    virtual status_t            StartSaver(BView *view, bool preview);
     22    virtual void                StopSaver();
     23
     24    virtual void                Draw(BView *view, int32 frame);
     25
     26    virtual void                StartConfig(BView* view);
     27
     28private:
     29    BList                       fVectorIcons;
     30    int32                       fVectorIconsCount;
     31    IconDisplay*                fIcons;
     32
     33    BBitmap*                    fBackBitmap;
     34    BView*                      fBackView;
     35
     36    uint16                      fMinSize, fMaxSize;
     37};
     38
     39#endif

  • src/add-ons/screen_savers/icons/IconDisplay.h

     
     1/*
     2    Copyright 2009 Vincent Duvert, vincent.duvert@free.fr
     3    All rights reserved. Distributed under the terms of the MIT License.
     4*/
     5
     6#ifndef ICON_DISPLAY_H
     7#define ICON_DISPLAY_H
     8
     9#include <Rect.h>
     10#include <View.h>
     11
     12struct VectorIcon {
     13        uint8* data;
     14        size_t size;
     15};
     16
     17
     18class BBitmap;
     19
     20
     21class IconDisplay {
     22public:
     23                                IconDisplay();
     24                                ~IconDisplay();
     25   
     26            void                Run(VectorIcon* icon, BRect frame);
     27    inline  bool                IsRunning() { return fIsRunning; };
     28    inline  BRect               GetFrame() { return fFrame; };
     29
     30            void                ClearOn(BView* view);
     31            void                DrawOn(BView* view, uint32 delta);
     32
     33private:
     34    bool                        fIsRunning;
     35    uint8                       fState;
     36   
     37    int32                       fTicks;
     38    int32                       fDelay;
     39
     40    BBitmap*                    fBitmap;
     41    BRect                       fFrame;
     42};
     43
     44#endif

  • src/add-ons/screen_savers/icons/Jamfile

     
     1SubDir HAIKU_TOP src add-ons screen_savers icons ;
     2
     3UseLibraryHeaders icon ;
     4
     5ScreenSaver Icons :
     6    IconDisplay.cpp IconsSaver.cpp :
     7    be libscreensaver.so libicon.a $(TARGET_LIBSUPC++)
     8;

  • src/add-ons/screen_savers/icons/IconsSaver.cpp

     
     1/*
     2    Copyright 2009 Vincent Duvert, vincent.duvert@free.fr
     3    All rights reserved. Distributed under the terms of the MIT License.
     4*/
     5
     6#include "IconsSaver.h"
     7
     8#include <stdio.h>
     9#include <stdlib.h>
     10
     11#include <Bitmap.h>
     12#include <MimeType.h>
     13#include <StringView.h>
     14
     15#include "IconDisplay.h"
     16
     17
     18#define MAX_ICONS 15
     19#define MAX_SIZE 20 // In percentage of the screen width
     20#define MIN_SIZE 5 // Same here
     21#define RAND_BETWEEN(a, b) ((rand() % ((b) - (a) + 1) + (a)))
     22
     23
     24const rgb_color kBackgroundColor = ui_color(B_DESKTOP_COLOR);
     25
     26
     27BScreenSaver* instantiate_screen_saver(BMessage* msg, image_id image)
     28{
     29    return new IconsSaver(msg, image);
     30}
     31
     32
     33IconsSaver::IconsSaver(BMessage* msg, image_id image)
     34    :
     35    BScreenSaver(msg, image),
     36    fVectorIconsCount(0),
     37    fIcons(NULL),
     38    fBackBitmap(NULL),
     39    fBackView(NULL),
     40    fMinSize(0),
     41    fMaxSize(0)
     42{
     43}
     44
     45
     46IconsSaver::~IconsSaver()
     47{
     48}
     49
     50
     51status_t
     52IconsSaver::StartSaver(BView *view, bool /*preview*/)
     53{
     54    if (fVectorIconsCount <= 0) {
     55        // Load the vector icons from the MIME types
     56        BMessage types;
     57        BMimeType::GetInstalledTypes(&types);
     58
     59        for (int32 index = 0 ; ; index++) {
     60            const char* type;
     61            if (types.FindString("types", index, &type) != B_OK)
     62                break;
     63
     64            BMimeType mimeType(type);
     65            uint8* vectorData = NULL;
     66            size_t size = 0;
     67
     68            if (mimeType.GetIcon(&vectorData, &size) != B_OK || size == 0)
     69                continue;
     70
     71            VectorIcon* icon = new VectorIcon;
     72            icon->data = vectorData;
     73            icon->size = size;
     74
     75            fVectorIcons.AddItem(icon);
     76        }
     77
     78        fVectorIconsCount = fVectorIcons.CountItems();
     79    }
     80
     81    srand(system_time() % INT_MAX);
     82
     83    BRect screenRect(0, 0, view->Frame().Width(), view->Frame().Height());
     84    fBackBitmap = new BBitmap(screenRect, B_RGBA32, true);
     85    if (!fBackBitmap->IsValid())
     86        return B_NO_MEMORY;
     87
     88    fBackView = new BView(screenRect, "back view", 0, 0);
     89    if (fBackView == NULL)
     90        return B_NO_MEMORY;
     91
     92    fBackView->SetViewColor(kBackgroundColor);
     93    fBackView->SetHighColor(kBackgroundColor);
     94
     95    fBackBitmap->AddChild(fBackView);
     96    if (fBackBitmap->Lock()) {
     97        fBackView->FillRect(fBackView->Frame());
     98        fBackView->SetDrawingMode(B_OP_ALPHA);
     99        fBackView->SetBlendingMode(B_CONSTANT_ALPHA, B_ALPHA_OVERLAY);
     100        fBackView->Sync();
     101        fBackBitmap->Unlock();
     102    }
     103
     104    fIcons = new IconDisplay[MAX_ICONS];
     105
     106    fMaxSize = (screenRect.IntegerWidth() * MAX_SIZE) / 100;
     107    fMinSize = (screenRect.IntegerWidth() * MIN_SIZE) / 100;
     108    if (fMaxSize > 255)
     109        fMaxSize = 255;
     110
     111    if (fMaxSize > screenRect.IntegerHeight())
     112        fMaxSize = screenRect.IntegerHeight();
     113
     114    if (fMinSize > fMaxSize)
     115        fMinSize = fMaxSize;
     116
     117    return B_OK;
     118}
     119
     120
     121void
     122IconsSaver::StopSaver()
     123{
     124    delete[] fIcons;
     125}
     126
     127
     128void
     129IconsSaver::Draw(BView *view, int32 frame)
     130{
     131    static int32 previousFrame = 0;
     132
     133    // Update drawing
     134    if (fBackBitmap->Lock()) {
     135        for (uint8 i = 0 ; i < MAX_ICONS ; i++) {
     136            fIcons[i].ClearOn(fBackView);
     137        }
     138
     139        int32 delta = frame - previousFrame;
     140
     141        for (uint8 i = 0 ; i < MAX_ICONS ; i++) {
     142            fIcons[i].DrawOn(fBackView, delta);
     143        }
     144        fBackView->Sync();
     145        fBackBitmap->Unlock();
     146    }
     147
     148    // Sync the view with the back buffer
     149    view->DrawBitmap(fBackBitmap);
     150    previousFrame = frame;
     151
     152    if (fVectorIconsCount <= 0)
     153        return;
     154
     155    // Restart one icon
     156    for (uint8 i = 0 ; i < MAX_ICONS ; i++) {
     157        if (!fIcons[i].IsRunning()) {
     158            uint16 size = RAND_BETWEEN(fMinSize, fMaxSize);
     159            uint16 maxX = view->Frame().IntegerWidth() - size;
     160            uint16 maxY = view->Frame().IntegerHeight() - size;
     161
     162            BRect iconFrame(0, 0, size, size);
     163            iconFrame.OffsetTo(RAND_BETWEEN(0, maxX), RAND_BETWEEN(0, maxY));
     164
     165            // Check that the icon doesn't overlap with others
     166            for (uint8 j = 0 ; j < MAX_ICONS ; j++) {
     167                if (fIcons[j].IsRunning() &&
     168                    iconFrame.Intersects(fIcons[j].GetFrame()))
     169                    return;
     170            }
     171
     172            int32 index = RAND_BETWEEN(0, fVectorIconsCount - 1);
     173
     174            fIcons[i].Run((VectorIcon*)fVectorIcons.ItemAt(index), iconFrame);
     175
     176            return;
     177        }
     178    }
     179}
     180
     181
     182void
     183IconsSaver::StartConfig(BView* view)
     184{
     185    const uint8 spacer = 5;
     186    BRect frame = view->Frame();
     187    BRect position(spacer, spacer, frame.Width() - 2 * spacer, 0);
     188
     189    view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
     190
     191    BStringView* stringView = new BStringView(position, "", "Icons");
     192    stringView->SetFont(be_bold_font);
     193    stringView->ResizeToPreferred();
     194    position.top += stringView->Frame().Height();
     195    view->AddChild(stringView);
     196
     197    stringView = new BStringView(position, "", "By Vincent Duvert");
     198    stringView->ResizeToPreferred();
     199    position.top += stringView->Frame().Height();
     200    view->AddChild(stringView);
     201}
     202